up-port of the stacked channel implementation rewrite in 8.3.2 to

8.4a2 code base, merged in with some existing new 8.4a2 features.

1 files changed, 2489 insertions, 1611 deletions

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 30161dc..5e12182 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -4,19 +4,21 @@
  *	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.
- * Copyright (c) 1998-2000 Scriptics Corporation
  *
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclIO.c,v 1.23 2000/05/19 21:30:15 hobbs Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.24 2000/09/28 06:38:20 hobbs Exp $
  */
 
 #include "tclInt.h"
 #include "tclPort.h"
 #include "tclIO.h"
+#include <assert.h>
 
+
 /*
  * All static variables used in this file are collected into a single
  * instance of the following structure.  For multi-threaded implementations,
@@ -35,9 +37,10 @@ typedef struct ThreadSpecificData {
     NextChannelHandler *nestedHandlerPtr;
 
     /*
-     * List of all channels currently open.
+     * List of all channels currently open, indexed by ChannelState,
+     * as only one ChannelState exists per set of stacked channels.
      */
-    Channel *firstChanPtr;
+    ChannelState *firstCSPtr;
 #ifdef oldcode
     /*
      * Has a channel exit handler been created yet?
@@ -64,77 +67,83 @@ typedef struct ThreadSpecificData {
 
 static Tcl_ThreadDataKey dataKey;
 
-
 /*
  * Static functions in this file:
  */
 
 static ChannelBuffer *	AllocChannelBuffer _ANSI_ARGS_((int length));
 static void		ChannelTimerProc _ANSI_ARGS_((
-			    ClientData clientData));
-static int		CheckChannelErrors _ANSI_ARGS_((Channel *chanPtr,
-			    int direction));
+				ClientData clientData));
+static int		CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr,
+				int direction));
 static int		CheckFlush _ANSI_ARGS_((Channel *chanPtr,
-			    ChannelBuffer *bufPtr, int newlineFlag));
+				ChannelBuffer *bufPtr, int newlineFlag));
 static int		CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
-			    Channel *chan));
+				ChannelState *statePtr));
 static void		CheckForStdChannelsBeingClosed _ANSI_ARGS_((
-			    Tcl_Channel chan));
+				Tcl_Channel chan));
 static void		CleanupChannelHandlers _ANSI_ARGS_((
-			    Tcl_Interp *interp, Channel *chanPtr));
+				Tcl_Interp *interp, Channel *chanPtr));
 static int		CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
-                            Channel *chanPtr, int errorCode));
+				Channel *chanPtr, int errorCode));
 static void		CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr,
-			    Tcl_Encoding encoding));
+				Tcl_Encoding encoding));
 static int		CopyAndTranslateBuffer _ANSI_ARGS_((
-			    Channel *chanPtr, char *result, int space));
+				ChannelState *statePtr, char *result,
+				int space));
+static int		CopyBuffer _ANSI_ARGS_((
+				Channel *chanPtr, char *result,
+				int space));
 static int		CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
 static void		CopyEventProc _ANSI_ARGS_((ClientData clientData,
-			    int mask));
+				int mask));
 static void		CreateScriptRecord _ANSI_ARGS_((
-			    Tcl_Interp *interp, Channel *chanPtr,
-                            int mask, Tcl_Obj *scriptPtr));
+				Tcl_Interp *interp, Channel *chanPtr,
+				int mask, Tcl_Obj *scriptPtr));
 static void		DeleteChannelTable _ANSI_ARGS_((
-			    ClientData clientData, Tcl_Interp *interp));
+				ClientData clientData, Tcl_Interp *interp));
 static void		DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
-        		    Channel *chanPtr, int mask));
-static void		DiscardInputQueued _ANSI_ARGS_((
-			    Channel *chanPtr, int discardSavedBuffers));
+				Channel *chanPtr, int mask));
+static void		DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr,
+				int discardSavedBuffers));
 static void		DiscardOutputQueued _ANSI_ARGS_((
-    			    Channel *chanPtr));
+				ChannelState *chanPtr));
 static int		DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
-			    int slen));
+				int slen));
 static int		DoWrite _ANSI_ARGS_((Channel *chanPtr, char *src,
-			    int srcLen));
+				int srcLen));
 static int		FilterInputBytes _ANSI_ARGS_((Channel *chanPtr,
-			    GetsState *statePtr));
+				GetsState *statePtr));
 static int		FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
-                            Channel *chanPtr, int calledFromAsyncFlush));
+				Channel *chanPtr, int calledFromAsyncFlush));
 static Tcl_HashTable *	GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
 static int		GetInput _ANSI_ARGS_((Channel *chanPtr));
 static void		PeekAhead _ANSI_ARGS_((Channel *chanPtr,
-			    char **dstEndPtr, GetsState *gsPtr));
-static int		ReadBytes _ANSI_ARGS_((Channel *chanPtr,
-			    Tcl_Obj *objPtr, int charsLeft, int *offsetPtr));
-static int		ReadChars _ANSI_ARGS_((Channel *chanPtr,
-			    Tcl_Obj *objPtr, int charsLeft, int *offsetPtr,
-			    int *factorPtr));
-static void		RecycleBuffer _ANSI_ARGS_((Channel *chanPtr,
-		            ChannelBuffer *bufPtr, int mustDiscard));
+				char **dstEndPtr, GetsState *gsPtr));
+static int		ReadBytes _ANSI_ARGS_((ChannelState *statePtr,
+				Tcl_Obj *objPtr, int charsLeft,
+				int *offsetPtr));
+static int		ReadChars _ANSI_ARGS_((ChannelState *statePtr,
+				Tcl_Obj *objPtr, int charsLeft, int *offsetPtr,
+				int *factorPtr));
+static void		RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr,
+				ChannelBuffer *bufPtr, int mustDiscard));
+static int		StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr,
+				int mode));
 static int		SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
-		            Channel *chanPtr, int mode));
+				Channel *chanPtr, int mode));
 static void		StopCopy _ANSI_ARGS_((CopyState *csPtr));
-static int		TranslateInputEOL _ANSI_ARGS_((Channel *chanPtr,
-			    char *dst, CONST char *src, int *dstLenPtr,
-			    int *srcLenPtr));
-static int		TranslateOutputEOL _ANSI_ARGS_((Channel *chanPtr,
-			    char *dst, CONST char *src, int *dstLenPtr,
-			    int *srcLenPtr));
+static int		TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr,
+				char *dst, CONST char *src, int *dstLenPtr,
+				int *srcLenPtr));
+static int		TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr,
+				char *dst, CONST char *src, int *dstLenPtr,
+				int *srcLenPtr));
 static void		UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
 static int		WriteBytes _ANSI_ARGS_((Channel *chanPtr,
-			    CONST char *src, int srcLen));
+				CONST char *src, int srcLen));
 static int		WriteChars _ANSI_ARGS_((Channel *chanPtr,
-			    CONST char *src, int srcLen));
+				CONST char *src, int srcLen));
 
 
 /*
@@ -188,12 +197,13 @@ TclFinalizeIOSubsystem()
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     Channel *chanPtr;			/* Iterates over open channels. */
-    Channel *nextChanPtr;		/* Iterates over open channels. */
-
+    ChannelState *nextCSPtr;		/* Iterates over open channels. */
+    ChannelState *statePtr;		/* state of channel stack */
 
-    for (chanPtr = tsdPtr->firstChanPtr; chanPtr != (Channel *) NULL;
-             chanPtr = nextChanPtr) {
-        nextChanPtr = chanPtr->nextChanPtr;
+    for (statePtr = tsdPtr->firstCSPtr; statePtr != (ChannelState *) NULL;
+	 statePtr = nextCSPtr) {
+	chanPtr		= statePtr->topChanPtr;
+        nextCSPtr	= statePtr->nextCSPtr;
 
         /*
          * Set the channel back into blocking mode to ensure that we wait
@@ -212,10 +222,10 @@ TclFinalizeIOSubsystem()
              * up to keep the channel from being closed.
              */
 
-            chanPtr->refCount--;
+            statePtr->refCount--;
         }
 
-        if (chanPtr->refCount <= 0) {
+        if (statePtr->refCount <= 0) {
 
 	    /*
              * Close it only if the refcount indicates that the channel is not
@@ -254,7 +264,7 @@ TclFinalizeIOSubsystem()
              */
 
             chanPtr->instanceData = (ClientData) NULL;
-            chanPtr->flags |= CHANNEL_DEAD;
+            statePtr->flags |= CHANNEL_DEAD;
         }
     }
 }
@@ -403,17 +413,17 @@ Tcl_CreateCloseHandler(chan, proc, clientData)
     ClientData clientData;	/* Arbitrary data to pass to the
                                  * close callback. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr;
     CloseCallback *cbPtr;
 
-    chanPtr = (Channel *) chan;
+    statePtr = ((Channel *) chan)->state;
 
     cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
     cbPtr->proc = proc;
     cbPtr->clientData = clientData;
 
-    cbPtr->nextPtr = chanPtr->closeCbPtr;
-    chanPtr->closeCbPtr = cbPtr;
+    cbPtr->nextPtr = statePtr->closeCbPtr;
+    statePtr->closeCbPtr = cbPtr;
 }
 
 /*
@@ -444,16 +454,16 @@ Tcl_DeleteCloseHandler(chan, proc, clientData)
     ClientData clientData;	/* The callback data for the callback
                                  * to remove. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr;
     CloseCallback *cbPtr, *cbPrevPtr;
 
-    chanPtr = (Channel *) chan;
-    for (cbPtr = chanPtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
-             cbPtr != (CloseCallback *) NULL;
-             cbPtr = cbPtr->nextPtr) {
+    statePtr = ((Channel *) chan)->state;
+    for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
+	 cbPtr != (CloseCallback *) NULL;
+	 cbPtr = cbPtr->nextPtr) {
         if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
             if (cbPrevPtr == (CloseCallback *) NULL) {
-                chanPtr->closeCbPtr = cbPtr->nextPtr;
+                statePtr->closeCbPtr = cbPtr->nextPtr;
             }
             ckfree((char *) cbPtr);
             break;
@@ -553,12 +563,13 @@ DeleteChannelTable(clientData, interp)
     Tcl_HashTable *hTblPtr;	/* The hash table. */
     Tcl_HashSearch hSearch;	/* Search variable. */
     Tcl_HashEntry *hPtr;	/* Search variable. */
-    Channel *chanPtr;	/* Channel being deleted. */
+    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.
@@ -566,23 +577,24 @@ DeleteChannelTable(clientData, interp)
     
     hTblPtr = (Tcl_HashTable *) clientData;
     for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
-             hPtr != (Tcl_HashEntry *) NULL;
-             hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
+	 hPtr != (Tcl_HashEntry *) NULL;
+	 hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
 
         chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
+	statePtr = chanPtr->state;
 
         /*
          * Remove any fileevents registered in this interpreter.
          */
         
-        for (sPtr = chanPtr->scriptRecordPtr,
+        for (sPtr = statePtr->scriptRecordPtr,
                  prevPtr = (EventScriptRecord *) NULL;
-                 sPtr != (EventScriptRecord *) NULL;
-                 sPtr = nextPtr) {
+	     sPtr != (EventScriptRecord *) NULL;
+	     sPtr = nextPtr) {
             nextPtr = sPtr->nextPtr;
             if (sPtr->interp == interp) {
                 if (prevPtr == (EventScriptRecord *) NULL) {
-                    chanPtr->scriptRecordPtr = nextPtr;
+                    statePtr->scriptRecordPtr = nextPtr;
                 } else {
                     prevPtr->nextPtr = nextPtr;
                 }
@@ -605,9 +617,9 @@ DeleteChannelTable(clientData, interp)
          */
 
         Tcl_DeleteHashEntry(hPtr);
-        chanPtr->refCount--;
-        if (chanPtr->refCount <= 0) {
-            if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+        statePtr->refCount--;
+        if (statePtr->refCount <= 0) {
+            if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
                 (void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
             }
         }
@@ -642,24 +654,26 @@ static void
 CheckForStdChannelsBeingClosed(chan)
     Tcl_Channel chan;
 {
-    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = ((Channel *) chan)->state;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) {
-        if (chanPtr->refCount < 2) {
-            chanPtr->refCount = 0;
+        if (statePtr->refCount < 2) {
+            statePtr->refCount = 0;
             tsdPtr->stdinChannel = NULL;
             return;
         }
-    } else if ((chan == tsdPtr->stdoutChannel) && (tsdPtr->stdoutInitialized)) {
-        if (chanPtr->refCount < 2) {
-            chanPtr->refCount = 0;
+    } else if ((chan == tsdPtr->stdoutChannel)
+	    && (tsdPtr->stdoutInitialized)) {
+        if (statePtr->refCount < 2) {
+            statePtr->refCount = 0;
             tsdPtr->stdoutChannel = NULL;
             return;
         }
-    } else if ((chan == tsdPtr->stderrChannel) && (tsdPtr->stderrInitialized)) {
-        if (chanPtr->refCount < 2) {
-            chanPtr->refCount = 0;
+    } else if ((chan == tsdPtr->stderrChannel)
+	    && (tsdPtr->stderrInitialized)) {
+        if (statePtr->refCount < 2) {
+            statePtr->refCount = 0;
             tsdPtr->stderrChannel = NULL;
             return;
         }
@@ -694,38 +708,32 @@ Tcl_RegisterChannel(interp, chan)
     Tcl_HashEntry *hPtr;	/* Search variable. */
     int new;			/* Is the hash entry new or does it exist? */
     Channel *chanPtr;		/* The actual channel. */
+    ChannelState *statePtr;	/* State of the actual channel. */
 
-    chanPtr = (Channel *) chan;
+    /*
+     * 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 (chanPtr->channelName == (char *) NULL) {
+    if (statePtr->channelName == (char *) NULL) {
         panic("Tcl_RegisterChannel: channel without name");
     }
     if (interp != (Tcl_Interp *) NULL) {
         hTblPtr = GetChannelTable(interp);
-        hPtr = Tcl_CreateHashEntry(hTblPtr, chanPtr->channelName, &new);
+        hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new);
         if (new == 0) {
             if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
                 return;
             }
 
-	    /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998
-	     * "Trf-Patch for filtering channels"
-	     *
-	     * This is the change to 'Tcl_RegisterChannel'.
-	     *
-	     * Explanation:
-	     *		The moment a channel is stacked upon another he
-	     *		takes the identity of the channel he supercedes,
-	     *		i.e. he gets the *same* name. Because of this we
-	     *		cannot check for duplicate names anymore, they
-	     *		have to be allowed now.
-	     */
-
-	    /* panic("Tcl_RegisterChannel: duplicate channel names"); */
+	    panic("Tcl_RegisterChannel: duplicate channel names");
         }
         Tcl_SetHashValue(hPtr, (ClientData) chanPtr);
     }
-    chanPtr->refCount++;
+    statePtr->refCount++;
 }
 
 /*
@@ -754,15 +762,22 @@ Tcl_UnregisterChannel(interp, chan)
     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;
 
-    chanPtr = (Channel *) chan;
-    
     if (interp != (Tcl_Interp *) NULL) {
         hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
         if (hTblPtr == (Tcl_HashTable *) NULL) {
             return TCL_OK;
         }
-        hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
+        hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
         if (hPtr == (Tcl_HashEntry *) NULL) {
             return TCL_OK;
         }
@@ -782,7 +797,7 @@ Tcl_UnregisterChannel(interp, chan)
         CleanupChannelHandlers(interp, chanPtr);
     }
 
-    chanPtr->refCount--;
+    statePtr->refCount--;
     
     /*
      * Perform special handling for standard channels being closed. If the
@@ -798,20 +813,20 @@ Tcl_UnregisterChannel(interp, chan)
      * If the refCount reached zero, close the actual channel.
      */
 
-    if (chanPtr->refCount <= 0) {
+    if (statePtr->refCount <= 0) {
 
         /*
          * Ensure that if there is another buffer, it gets flushed
          * whether or not we are doing a background flush.
          */
 
-        if ((chanPtr->curOutPtr != NULL) &&
-                (chanPtr->curOutPtr->nextAdded >
-                        chanPtr->curOutPtr->nextRemoved)) {
-            chanPtr->flags |= BUFFER_READY;
+        if ((statePtr->curOutPtr != NULL) &&
+                (statePtr->curOutPtr->nextAdded >
+                        statePtr->curOutPtr->nextRemoved)) {
+            statePtr->flags |= BUFFER_READY;
         }
-        chanPtr->flags |= CHANNEL_CLOSED;
-        if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+        statePtr->flags |= CHANNEL_CLOSED;
+        if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
             if (Tcl_Close(interp, chan) != TCL_OK) {
                 return TCL_ERROR;
             }
@@ -821,134 +836,6 @@ Tcl_UnregisterChannel(interp, chan)
 }
 
 /*
- *----------------------------------------------------------------------
- *
- * Tcl_IsChannelRegistered --
- *
- *	Checks whether the channel is associated with the interp.
- *
- * Results:
- *	0 if the channel is not registered in the interpreter, 1 else.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_IsChannelRegistered (interp, chan)
-     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. */
-
-    chanPtr = (Channel *) chan;
-    hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
-
-    if (hTblPtr == (Tcl_HashTable *) NULL) {
-        return 0;
-    }
-
-    hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
-
-    if (hPtr == (Tcl_HashEntry *) 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 (chan)
-    Tcl_Channel chan;	/* The channel to query */
-{
-    Channel *chanPtr;	/* The real IO channel. */
-
-    chanPtr = (Channel *) chan;
-
-    return (chanPtr->refCount > 1) ? 1 : 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_IsChannelExisting --
- *
- *	Checks whether a channel of the given name exists in the
- *	(thread)-global list of all channels.
- *
- * Results:
- *	A boolean value (0 = Does not exist, 1 = Does exist).
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_IsChannelExisting (chanName)
-    CONST char* chanName;	/* The name of the channel to look for. */
-{
-    Channel *chanPtr;
-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-    char *name;
-    int cLen, nLen, match;
-
-    cLen = strlen (chanName);
-
-    for (chanPtr = tsdPtr->firstChanPtr;
-	 chanPtr != NULL;
-	 chanPtr = chanPtr->nextChanPtr) {
-        if (chanPtr == (Channel *) tsdPtr->stdinChannel) {
-	    name = "stdin";
-	} else if (chanPtr == (Channel *) tsdPtr->stdoutChannel) {
-	    name = "stdout";
-	} else if (chanPtr == (Channel *) tsdPtr->stderrChannel) {
-	    name = "stderr";
-	} else {
-	    name = chanPtr->channelName;
-	}
-
-	nLen = strlen (name);
-
-	if (nLen != cLen) {
-	    continue;
-	}
-
-	match = memcmp(name, chanName, (unsigned) cLen);
-
-	if (match == 0) {
-	    return 1;
-	}
-    }
-
-    return 0;
-}
-
-/*
  *---------------------------------------------------------------------------
  *
  * Tcl_GetChannel --
@@ -995,17 +882,17 @@ Tcl_GetChannel(interp, chanName, modePtr)
     if ((chanName[0] == 's') && (chanName[1] == 't')) {
 	chanPtr = NULL;
 	if (strcmp(chanName, "stdin") == 0) {
-	    chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDIN);
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDIN);
 	} else if (strcmp(chanName, "stdout") == 0) {
-	    chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDOUT);
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDOUT);
 	} else if (strcmp(chanName, "stderr") == 0) {
-	    chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDERR);
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDERR);
 	}
 	if (chanPtr != NULL) {
-	    name = chanPtr->channelName;
+	    name = chanPtr->state->channelName;
 	}
     }
-    
+
     hTblPtr = GetChannelTable(interp);
     hPtr = Tcl_FindHashEntry(hTblPtr, name);
     if (hPtr == (Tcl_HashEntry *) NULL) {
@@ -1014,9 +901,16 @@ Tcl_GetChannel(interp, chanName, modePtr)
         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 = (Channel *) Tcl_GetHashValue(hPtr);
+    chanPtr = chanPtr->state->bottomChanPtr;
     if (modePtr != NULL) {
-        *modePtr = (chanPtr->flags & (TCL_READABLE|TCL_WRITABLE));
+        *modePtr = (chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE));
     }
     
     return (Tcl_Channel) chanPtr;
@@ -1049,33 +943,61 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
                                  * 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;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
-    
+    /*
+     * 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*));
+
+    /*
+     * JH: We could subsequently memset these to 0 to avoid the
+     * numerous assignments to 0/NULL below.
+     */
+    chanPtr  = (Channel *) ckalloc((unsigned) sizeof(Channel));
+    statePtr = (ChannelState *) ckalloc((unsigned) 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 != (char *) NULL) {
-        chanPtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
-        strcpy(chanPtr->channelName, chanName);
+        statePtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
+        strcpy(statePtr->channelName, chanName);
     } else {
         panic("Tcl_CreateChannel: NULL channel name");
     }
 
-    chanPtr->flags = mask;
+    statePtr->flags		= mask;
 
     /*
      * Set the channel to system default encoding.
      */
 
-    chanPtr->encoding = NULL;
+    statePtr->encoding = NULL;
     name = Tcl_GetEncodingName(NULL);
     if (strcmp(name, "binary") != 0) {
-    	chanPtr->encoding = Tcl_GetEncoding(NULL, name);
+    	statePtr->encoding = Tcl_GetEncoding(NULL, name);
     }
-    chanPtr->inputEncodingState = NULL;
-    chanPtr->inputEncodingFlags = TCL_ENCODING_START;
-    chanPtr->outputEncodingState = NULL;
-    chanPtr->outputEncodingFlags = TCL_ENCODING_START;
+    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
@@ -1085,58 +1007,70 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
      * indicator (e.g. ^Z) and does not append an EOF indicator to files.
      */
 
-    chanPtr->inputTranslation = TCL_TRANSLATE_AUTO;
-    chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
-    chanPtr->inEofChar = 0;
-    chanPtr->outEofChar = 0;
-
-    chanPtr->unreportedError = 0;
-    chanPtr->instanceData = instanceData;
-    chanPtr->typePtr = typePtr;
-    chanPtr->refCount = 0;
-    chanPtr->closeCbPtr = (CloseCallback *) NULL;
-    chanPtr->curOutPtr = (ChannelBuffer *) NULL;
-    chanPtr->outQueueHead = (ChannelBuffer *) NULL;
-    chanPtr->outQueueTail = (ChannelBuffer *) NULL;
-    chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
-    chanPtr->inQueueHead = (ChannelBuffer *) NULL;
-    chanPtr->inQueueTail = (ChannelBuffer *) NULL;
-    chanPtr->chPtr = (ChannelHandler *) NULL;
-    chanPtr->interestMask = 0;
-    chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
-    chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
-    chanPtr->timer = NULL;
-    chanPtr->csPtr = NULL;
-    chanPtr->supercedes  = (Channel*) NULL;
-    chanPtr->nextChanPtr = (Channel*) NULL;
-
-    chanPtr->outputStage = NULL;
-    if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
-	chanPtr->outputStage = (char *)
-		ckalloc((unsigned) (chanPtr->bufSize + 2));
+    statePtr->inputTranslation	= TCL_TRANSLATE_AUTO;
+    statePtr->outputTranslation	= TCL_PLATFORM_TRANSLATION;
+    statePtr->inEofChar		= 0;
+    statePtr->outEofChar	= 0;
+
+    statePtr->unreportedError	= 0;
+    statePtr->refCount		= 0;
+    statePtr->closeCbPtr	= (CloseCallback *) NULL;
+    statePtr->curOutPtr		= (ChannelBuffer *) NULL;
+    statePtr->outQueueHead	= (ChannelBuffer *) NULL;
+    statePtr->outQueueTail	= (ChannelBuffer *) NULL;
+    statePtr->saveInBufPtr	= (ChannelBuffer *) NULL;
+    statePtr->inQueueHead	= (ChannelBuffer *) NULL;
+    statePtr->inQueueTail	= (ChannelBuffer *) NULL;
+    statePtr->chPtr		= (ChannelHandler *) NULL;
+    statePtr->interestMask	= 0;
+    statePtr->scriptRecordPtr	= (EventScriptRecord *) NULL;
+    statePtr->bufSize		= CHANNELBUFFER_DEFAULT_SIZE;
+    statePtr->timer		= NULL;
+    statePtr->csPtr		= NULL;
+
+    statePtr->outputStage	= NULL;
+    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+	statePtr->outputStage = (char *)
+	    ckalloc((unsigned) (statePtr->bufSize + 2));
     }
 
     /*
+     * As we are creating the channel, it is obviously the top for now
+     */
+    statePtr->topChanPtr	= chanPtr;
+    statePtr->bottomChanPtr	= chanPtr;
+    chanPtr->downChanPtr	= (Channel *) NULL;
+    chanPtr->upChanPtr		= (Channel *) NULL;
+    chanPtr->inQueueHead        = (ChannelBuffer*) NULL;
+    chanPtr->inQueueTail        = (ChannelBuffer*) NULL;
+
+    /*
      * 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.
      */
 
-    Tcl_SpliceChannel ((Tcl_Channel) chanPtr);
+    statePtr->nextCSPtr	= tsdPtr->firstCSPtr;
+    tsdPtr->firstCSPtr	= statePtr;
 
     /*
      * Install this channel in the first empty standard channel slot, if
      * the channel was previously closed explicitly.
      */
 
-    if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) {
-	Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDIN);
+    if ((tsdPtr->stdinChannel == NULL) &&
+	    (tsdPtr->stdinInitialized == 1)) {
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN);
         Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
-    } else if ((tsdPtr->stdoutChannel == NULL) && (tsdPtr->stdoutInitialized == 1)) {
-	Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDOUT);
+    } else if ((tsdPtr->stdoutChannel == NULL) &&
+	    (tsdPtr->stdoutInitialized == 1)) {
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT);
         Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
-    } else if ((tsdPtr->stderrChannel == NULL) && (tsdPtr->stderrInitialized == 1)) {
-	Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDERR);
+    } else if ((tsdPtr->stderrChannel == NULL) &&
+	    (tsdPtr->stderrInitialized == 1)) {
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR);
         Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
     } 
     return (Tcl_Channel) chanPtr;
@@ -1173,53 +1107,36 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
 
 Tcl_Channel
 Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
-    Tcl_Interp*      interp;       /* The interpreter we are working in */
+    Tcl_Interp	    *interp;	   /* The interpreter we are working in */
     Tcl_ChannelType *typePtr;	   /* The channel type record for the new
 				    * channel. */
-    ClientData       instanceData; /* Instance specific data for the new
+    ClientData	     instanceData; /* Instance specific data for the new
 				    * channel. */
-    int              mask;	   /* TCL_READABLE & TCL_WRITABLE to indicate
+    int		     mask;	   /* TCL_READABLE & TCL_WRITABLE to indicate
 				    * if the channel is readable, writable. */
-    Tcl_Channel      prevChan;	   /* The channel structure to replace */
+    Tcl_Channel	     prevChan;	   /* The channel structure to replace */
 {
-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-    Channel            *chanPtr, *pt;
-    int                 interest = 0;
-
-    /*
-     * AK, 06/30/1999
-     *
-     * Tcl_StackChannel differs from Tcl_ReplaceChannel of the
-     * original "Trf" patch. Instead of seeing the
-     * newly created structure as the *new* channel to cover the specified
-     * one use it to *save* the current state of the specified channel and
-     * then reinitialize the current structure for the given transformation.
-     *
-     * Advantages:
-     * - No splicing into the (thread-)global list of channels (or the per-
-     *   interp hash-tables).
-     * - Users of the C-API still have valid channel references even after
-     *   the call to this procedure.
-     *
-     * Disadvantages:
-     * - Untested code.
-     */
+    ThreadSpecificData	*tsdPtr = TCL_TSD_INIT(&dataKey);
+    Channel		*chanPtr, *prevChanPtr;
+    ChannelState	*statePtr;
 
     /*
      * Find the given channel in the list of all channels.
+     * If we don't find it, then it was never registered correctly.
+     *
+     * This operation should occur at the top of a channel stack.
      */
 
-    pt     = (Channel*) tsdPtr->firstChanPtr;
+    statePtr    = (ChannelState *) tsdPtr->firstCSPtr;
+    prevChanPtr = ((Channel *) prevChan)->state->topChanPtr;
 
-    while (pt != (Channel *) prevChan) {
-	pt = pt->nextChanPtr;
+    while (statePtr->topChanPtr != prevChanPtr) {
+	statePtr = statePtr->nextCSPtr;
     }
 
-    /*
-     * 'pt == prevChan' now (or NULL, if not found).
-     */
-
-    if (!pt) {
+    if (statePtr == NULL) {
+	Tcl_AppendResult(interp, "couldn't find state for channel \"",
+		Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
         return (Tcl_Channel) NULL;
     }
 
@@ -1236,189 +1153,93 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
      *	--+---+---+---+----+
      */
 
-    if ((mask & Tcl_GetChannelMode (prevChan)) == 0) {
+    if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) {
+	Tcl_AppendResult(interp,
+		"reading and writing both disallowed for channel \"",
+		Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
         return (Tcl_Channel) NULL;
     }
 
-    chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
-
     /*
-     * If there is some interest in the channel, remove it, break
-     * down the whole chain. It will be reconstructed later.
+     * 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.
      */
 
-    interest = pt->interestMask;
-
-    pt->interestMask = 0;
+    if ((mask & TCL_WRITABLE) != 0) {
+        CopyState *csPtr;
 
-    if (interest) {
-        (pt->typePtr->watchProc) (pt->instanceData, 0);
-    }
+        csPtr           = statePtr->csPtr;
+	statePtr->csPtr = (CopyState*) NULL;
 
-    /*
-     * Save some of the current state into the new structure,
-     * reinitialize the parts which will stay with the transformation.
-     *
-     * Remarks:
-     * - We cannot discard the buffers, and they cannot be used from the
-     *   transformation placed later into the 'pt' structure. Save them,
-     *   and believe that Tcl_SetChannelOption (buffering, none) will do
-     *   the right thing.
-     * - encoding and EOL-translation control information is initialized
-     *   to values for 'binary'. This is later reinforced via
-     *   Tcl_SetChanneloption to get the handling of flags and the event
-     *   system right.
-     * - The 'interestMask' of the saved channel is cleared, but the
-     *   transformations WatchProc is used to establish the connection
-     *   between transformation and underlying channel. This should
-     *   reestablish the correct mask.
-     * - TTO = Transform Takes Over.   The hidden channel no longer
-     *         needs to perform this function.
-     */
-
-    chanPtr->channelName = (char *) ckalloc (strlen(pt->channelName)+1);
-    strcpy (chanPtr->channelName, pt->channelName);
-
-    chanPtr->flags               = pt->flags;           /* Save */
-
-    chanPtr->encoding            = (Tcl_Encoding) NULL; /* == 'binary' */
-    chanPtr->inputEncodingState  = (Tcl_EncodingState) NULL;
-    chanPtr->inputEncodingFlags  = TCL_ENCODING_START;
-    chanPtr->outputEncodingState = (Tcl_EncodingState) NULL;
-    chanPtr->outputEncodingFlags = TCL_ENCODING_START;
-
-    chanPtr->inputTranslation    = TCL_TRANSLATE_LF; /* == 'binary' */
-    chanPtr->outputTranslation   = TCL_TRANSLATE_LF; /* == 'binary' */
-    chanPtr->inEofChar           = pt->inEofChar;         /* Save */
-    chanPtr->outEofChar          = pt->outEofChar;        /* Save */
-
-    chanPtr->unreportedError     = pt->unreportedError;   /* Save */
-    chanPtr->instanceData        = pt->instanceData;      /* Save */
-    chanPtr->typePtr             = pt->typePtr;           /* Save */
-    chanPtr->refCount            = 0;   /* None, as the structure is covered */
-    chanPtr->closeCbPtr          = (CloseCallback*) NULL; /* TTO */
-
-    chanPtr->outputStage         = (char*) NULL;
-    chanPtr->curOutPtr           = pt->curOutPtr;    /* Save */
-    chanPtr->outQueueHead        = pt->outQueueHead; /* Save */
-    chanPtr->outQueueTail        = pt->outQueueTail; /* Save */
-    chanPtr->saveInBufPtr        = pt->saveInBufPtr; /* Save */
-    chanPtr->inQueueHead         = pt->inQueueHead;  /* Save */
-    chanPtr->inQueueTail         = pt->inQueueTail;  /* Save */
-
-    chanPtr->chPtr               = (ChannelHandler *) NULL;  /* TTO */
-    chanPtr->interestMask        = 0;
-    chanPtr->nextChanPtr         = (Channel*) NULL;     /* Is not in list! */
-    chanPtr->scriptRecordPtr     = (EventScriptRecord *) NULL; /* TTO */
-    chanPtr->bufSize             = CHANNELBUFFER_DEFAULT_SIZE;
-    chanPtr->timer               = (Tcl_TimerToken) NULL;      /* TTO */
-    chanPtr->csPtr               = (CopyState*) NULL;          /* TTO */
-
-    /*
-     * Place new block at the head of a possibly existing list of previously
-     * stacked channels, then do the missing initializations of translation
-     * and buffer system.
-     */
-
-    chanPtr->supercedes          = pt->supercedes;
-
-    Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
-	"-translation", "binary");
-    Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
-	"-buffering",   "none");
+	if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) {
+	    statePtr->csPtr = csPtr;
+	    Tcl_AppendResult(interp, "could not flush channel \"",
+		    Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+	    return (Tcl_Channel) NULL;
+	}
 
+	statePtr->csPtr = csPtr;
+    }
     /*
-     * Save accomplished, now reinitialize the (old) structure for the
-     * transformation.
+     * 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.
      *
-     * - The information about encoding and eol-translation is taken
-     *   without change.  There is no need to fiddle with
-     *   refCount et. al.
-     *
-     * Don't forget to use the same blocking mode as the old channel.
-     */
-
-    pt->flags               = mask | (chanPtr->flags & CHANNEL_NONBLOCKING);
-
-    /*
-     * EDITORS NOTE:  all the lines with "take it as is" should get
-     * deleted once this code has been debugged.
+     * 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.
      */
 
-    /* pt->encoding,            take it as is */
-    /* pt->inputEncodingState,  take it as is */
-    /* pt->inputEncodingFlags,  take it as is */
-    /* pt->outputEncodingState, take it as is */
-    /* pt->outputEncodingFlags, take it as is */
+    if (((mask & TCL_READABLE) != 0) &&
+	(statePtr->inQueueHead != (ChannelBuffer*) NULL)) {
+      /*
+       * Remark: It is possible that the channel buffers contain data from
+       * some earlier push-backs.
+       */
 
-    /* pt->inputTranslation,    take it as is */
-    /* pt->outputTranslation,   take it as is */
+      statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
+      prevChanPtr->inQueueHead       = statePtr->inQueueHead;
 
-    /*
-     * No special EOF character, that condition is determined by the
-     * old channel
-     */
-
-    pt->inEofChar           = 0;
-    pt->outEofChar          = 0;
-
-    pt->unreportedError     = 0; /* No errors yet */
-    pt->instanceData        = instanceData; /* Transformation state */
-    pt->typePtr             = typePtr;      /* Transformation type */
-    /* pt->refCount,            take it as it is */
-    /* pt->closeCbPtr,          take it as it is */
-
-    /* pt->outputStage,         take it as it is */
-    pt->curOutPtr           = (ChannelBuffer *) NULL;
-    pt->outQueueHead        = (ChannelBuffer *) NULL;
-    pt->outQueueTail        = (ChannelBuffer *) NULL;
-    pt->saveInBufPtr        = (ChannelBuffer *) NULL;
-    pt->inQueueHead         = (ChannelBuffer *) NULL;
-    pt->inQueueTail         = (ChannelBuffer *) NULL;
-
-    /* pt->chPtr,               take it as it is */
-    /* pt->interestMask,        take it as it is */
-    /* pt->nextChanPtr,         take it as it is */
-    /* pt->scriptRecordPtr,     take it as it is */
-    pt->bufSize             = CHANNELBUFFER_DEFAULT_SIZE;
-    /* pt->timer,               take it as it is */
-    /* pt->csPtr,               take it as it is */
+      if (prevChanPtr->inQueueTail == (ChannelBuffer*) NULL) {
+	prevChanPtr->inQueueTail = statePtr->inQueueTail;
+      }
 
-    /*
-     * Have the transformation reference the new structure containing
-     * the saved channel.
-     */
+      statePtr->inQueueHead          = (ChannelBuffer*) NULL;
+      statePtr->inQueueTail          = (ChannelBuffer*) NULL;
+    }
 
-    pt->supercedes          = chanPtr;
+    chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
 
     /*
-     * Don't forget to reinitialize the output buffer used for encodings.
+     * Save some of the current state into the new structure,
+     * reinitialize the parts which will stay with the transformation.
+     *
+     * Remarks:
      */
 
-    if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
-        chanPtr->outputStage = (char *)
-	    ckalloc((unsigned) (chanPtr->bufSize + 2));
-    }
+    chanPtr->state		= statePtr;
+    chanPtr->instanceData	= instanceData;
+    chanPtr->typePtr		= typePtr;
+    chanPtr->downChanPtr	= prevChanPtr;
+    chanPtr->upChanPtr		= (Channel *) NULL;
+    chanPtr->inQueueHead        = (ChannelBuffer*) NULL;
+    chanPtr->inQueueTail        = (ChannelBuffer*) NULL;
 
     /*
-     * Event handling: If the information in the old channel shows
-     * that there was interest in some events call the 'WatchProc'
-     * of the transformation to establish the proper connection
-     * between them.
+     * Place new block at the head of a possibly existing list of previously
+     * stacked channels.
      */
 
-    if (interest) {
-        (pt->typePtr->watchProc) (pt->instanceData, interest);
-    }
-
-    /*
-     * The superceded channel is effectively unregistered
-     * We cannot decrement its reference count because that
-     * can cause it to get garbage collected out from under us.
-     * Don't add the following code:
-     *
-     * chanPtr->supercedes->refCount --;
-     */
+    prevChanPtr->upChanPtr	= chanPtr;
+    statePtr->topChanPtr	= chanPtr;
 
     return (Tcl_Channel) chanPtr;
 }
@@ -1430,207 +1251,142 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
  *
  *	Unstacks an entry in the hash table for a Tcl_Channel
  *	record. This is the reverse to 'Tcl_StackChannel'.
- *	The old, superceded channel is uncovered and re-registered
- *	in the appropriate data structures.
  *
  * Results:
- *	Returns the old Tcl_Channel, i.e. the one which was stacked over.
+ *	A standard Tcl result.
  *
  * Side effects:
- *	See above.
+ *	If TCL_ERROR is returned, the posix error code will be set
+ *	with Tcl_SetErrno.
  *
  *----------------------------------------------------------------------
  */
 
-void
+int
 Tcl_UnstackChannel (interp, chan)
-    Tcl_Interp* interp; /* The interpreter we are working in */
+    Tcl_Interp *interp; /* The interpreter we are working in */
     Tcl_Channel chan;   /* The channel to unstack */
 {
-    Channel* chanPtr = (Channel*) chan;
+    Channel      *chanPtr  = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+    int result = 0;
 
-    if (chanPtr->supercedes != (Channel*) NULL) {
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (chanPtr->downChanPtr != (Channel *) 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.
 	 */
-
-	Tcl_DString       dsTrans; /* storage to save option information */
-	Tcl_DString       dsBuf;   /* storage to save option information */
-	Channel           top;     /* Save area for current transformation */
-	Channel*          chanDownPtr = chanPtr->supercedes;
-	int               interest;	/* interest mask of transformation
-					 * before destruct. */
-	int               saveInputEncodingFlags;  /* Save area for encoding */
- 	int               saveOutputEncodingFlags; /* related information */
-	Tcl_EncodingState saveInputEncodingState;
-	Tcl_EncodingState saveOutputEncodingState;
-	Tcl_Encoding      saveEncoding;
+	Channel *downChanPtr = chanPtr->downChanPtr;
 
 	/*
-	 * Event handling: Disallow the delivery of events from the
-	 * old, now uncovered channel to the transformation.
-	 *
-	 * This is done before everything else to avoid problems
-	 * after our heavy-duty shuffling of pointers around.
+	 * 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.
 	 */
 
-	interest = chanPtr->interestMask;
-        (chanPtr->typePtr->watchProc) (chanPtr->instanceData, 0);
-
-	/* 1. Swap the information in the top channel (the transformation)
-	 *    and the channel below, with some exceptions. This additionally
-	 *    cuts the top channel out of the chain. Without the latter
-	 *    a Tcl_Close on the transformation would be impossible, as that
-	 *    procedure will free the structure, making 'top' unusable.
-	 *
-	 * chanPtr     -> top channel, transformation.
-	 * chanDownPtr -> channel immediately below the transformation.
-	 */
+	if (statePtr->flags & TCL_WRITABLE) {
+	    CopyState*    csPtr;
 
-	memcpy ((void*) &top,        (void*) chanPtr,     sizeof (Channel));
-	memcpy ((void*) chanPtr,     (void*) chanDownPtr, sizeof (Channel));
-	top.supercedes = (Channel*) NULL;
-	memcpy ((void*) chanDownPtr, (void*) &top,        sizeof (Channel));
-
-	/* Now:
- 	 * chanPtr     -> channel immediately below the transformation, now top
- 	 * chanDownPtr -> transformation, cut loose.
- 	 *
- 	 * Handle the exceptions mentioned above, i.e. move the information
- 	 * from the transformation into the new top, and reinitialize it to
- 	 * safe values in the transformation.
- 	 */
-
-	chanPtr->refCount        = chanDownPtr->refCount;
-	chanPtr->closeCbPtr      = chanDownPtr->closeCbPtr;
-	chanPtr->chPtr           = chanDownPtr->chPtr;
-	chanPtr->nextChanPtr     = chanDownPtr->nextChanPtr;
-	chanPtr->scriptRecordPtr = chanDownPtr->scriptRecordPtr;
-	chanPtr->timer           = chanDownPtr->timer;
-	chanPtr->csPtr           = chanDownPtr->csPtr;
-
-	chanDownPtr->refCount        = 0;
-	chanDownPtr->closeCbPtr      = (CloseCallback*) NULL;
-	chanDownPtr->chPtr           = (ChannelHandler*) NULL;
-	chanDownPtr->nextChanPtr     = (Channel*) NULL;
-	chanDownPtr->scriptRecordPtr = (EventScriptRecord*) NULL;
-	chanDownPtr->timer           = (Tcl_TimerToken) NULL;
-	chanDownPtr->csPtr           = (CopyState*) NULL;
-
-	/* The now uncovered channel still has encoding and eol-translation
-	 * deactivated, i.e. switched to 'binary'. *Don't* touch this until
-	 * after the transformation is closed for good, as it may write
-	 * information into it during that (-> flushing of data waiting in
-	 * internal buffers!) and rely on these settings. Thanks to Matt
-	 * Newman <matt@sensus.org> for finding this goof.
-	 *
-	 * But we also have to protect the state of the encoding from removal
-	 * during the close. So we save it in some local variables.
-	 * Additionally the current value of the options is lost after we
-	 * close, we have to save them now.
-	 */
+	    csPtr           = statePtr->csPtr;
+	    statePtr->csPtr = (CopyState*) NULL;
 
- 	saveEncoding            = chanDownPtr->encoding;
- 	saveInputEncodingState  = chanDownPtr->inputEncodingState;
- 	saveInputEncodingFlags  = chanDownPtr->inputEncodingFlags;
- 	saveOutputEncodingState = chanDownPtr->outputEncodingState;
- 	saveOutputEncodingFlags = chanDownPtr->outputEncodingFlags;
-
- 	Tcl_DStringInit (&dsTrans);
- 	Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr,
-		"-translation", &dsTrans);
+	    if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
+	        statePtr->csPtr = csPtr;
+		Tcl_AppendResult(interp, "could not flush channel \"",
+			Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
+			(char *) NULL);
+		return TCL_ERROR;
+	    }
 
- 	Tcl_DStringInit (&dsBuf);
- 	Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr,
-		"-buffering", &dsBuf);
+	    statePtr->csPtr = csPtr;
+	}
 
 	/*
-	 * Prevent the accidential removal of the encoding during
-	 * the destruction of the transformation channel.
+	 * 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.
 	 */
 
-	chanDownPtr->encoding            = (Tcl_Encoding) NULL;
-	chanDownPtr->inputEncodingState  = (Tcl_EncodingState) NULL;
-	chanDownPtr->inputEncodingFlags  = TCL_ENCODING_START;
-	chanDownPtr->outputEncodingState = (Tcl_EncodingState) NULL;
-	chanDownPtr->outputEncodingFlags = TCL_ENCODING_START;
+	if (((statePtr->flags & TCL_READABLE)  != 0) &&
+	    ((statePtr->inQueueHead != (ChannelBuffer*) NULL) ||
+	     (chanPtr->inQueueHead  != (ChannelBuffer*) NULL))) {
 
-	/*
-	 * A little trick: Add the transformation structure to the
-	 * per-thread list of existing channels (which it never were
-	 * part of so far), or Tcl_Close/FlushChannel will panic
-	 * ("damaged channel list").
-	 *
-	 * Afterward do a regular close upon the transformation.
-	 * This may cause flushing of data into the old channel (if the
-	 * transformation remembered its own channel in itself).
-	 *
-	 * We know that its refCount dropped to 0.
-	 */
+	    if ((statePtr->inQueueHead != (ChannelBuffer*) NULL) &&
+		(chanPtr->inQueueHead  != (ChannelBuffer*) NULL)) {
+	        statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
+		statePtr->inQueueTail = chanPtr->inQueueTail;
+	        statePtr->inQueueHead = statePtr->inQueueTail;
+
+	    } else if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
+	        statePtr->inQueueHead = chanPtr->inQueueHead;
+		statePtr->inQueueTail = chanPtr->inQueueTail;
+	    }
+
+	    chanPtr->inQueueHead          = (ChannelBuffer*) NULL;
+	    chanPtr->inQueueTail          = (ChannelBuffer*) NULL;
+
+	    DiscardInputQueued (statePtr, 0);
+	}
 
-	Tcl_SpliceChannel ((Tcl_Channel) chanDownPtr);
-	Tcl_Close (interp, (Tcl_Channel) chanDownPtr);
+	statePtr->topChanPtr	= downChanPtr;
+	downChanPtr->upChanPtr	= (Channel *) NULL;
 
 	/*
-	 * Now it is possible to wind down the transformation (in 'top'),
-	 * especially to copy the current encoding and translation control
-	 * information down.
+	 * Leave this link intact for closeproc
+	 *  chanPtr->downChanPtr	= (Channel *) NULL;
 	 */
-	
+
 	/*
-	 * Move the currently active encoding from the save area
-	 * to the now uncovered channel. We assume here that this
-	 * channel uses 'encoding binary' (==> encoding == NULL, etc.
-	 * This allows us to simply copy the pointers without having to
-	 * think about refcounts and deallocation of the old encoding.
-	 *
-	 * And don't forget to reenable the EOL-translation used by the
-	 * transformation. Using a DString to do this *is* a bit awkward,
-	 * but still the best way to handle the complexities here, like
-	 * flag manipulation and event system.
+	 * Close and free the channel driver state.
 	 */
 
-	chanPtr->encoding            = saveEncoding;
-	chanPtr->inputEncodingState  = saveInputEncodingState;
-	chanPtr->inputEncodingFlags  = saveInputEncodingFlags;
-	chanPtr->outputEncodingState = saveOutputEncodingState;
-	chanPtr->outputEncodingFlags = saveOutputEncodingFlags;
-
-	Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
-		"-translation", dsTrans.string);
-
-	Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
-		"-buffering", dsBuf.string);
-
-	Tcl_DStringFree (&dsTrans);
-	Tcl_DStringFree (&dsBuf);
+	if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
+	    result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData,
+		    interp);
+	} else {
+	    result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
+		    interp, 0);
+	}
 
+	chanPtr->typePtr	= NULL;
 	/*
-	 * Event handling: If the information from the now destroyed
-	 * transformation shows that there was interest in some events
-	 * call the 'WatchProc' of the now uncovered channel to renew
-	 * that interest with underlying channels or the driver.
+	 * AK: Tcl_NotifyChannel may hold a reference to this block of memory
 	 */
+	Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+	UpdateInterest(downChanPtr);
 
-	if (interest) {
-	    chanPtr->interestMask = 0;
-	    (chanPtr->typePtr->watchProc) (chanPtr->instanceData,
-		interest);
-	    chanPtr->interestMask = interest;
+	if (result != 0) {
+	    Tcl_SetErrno(result);
+	    return TCL_ERROR;
 	}
-
     } else {
-        /* This channel does not cover another one.
+        /*
+	 * This channel does not cover another one.
 	 * Simply do a close, if necessary.
 	 */
 
-        if (chanPtr->refCount == 0) {
-	    Tcl_Close (interp, chan);
+        if (statePtr->refCount <= 0) {
+            if (Tcl_Close(interp, chan) != TCL_OK) {
+                return TCL_ERROR;
+            }
 	}
     }
+
+    return TCL_OK;
 }
 
 /*
@@ -1638,7 +1394,7 @@ Tcl_UnstackChannel (interp, chan)
  *
  * Tcl_GetStackedChannel --
  *
- *	Determines wether the specified channel is stacked upon another.
+ *	Determines whether the specified channel is stacked upon another.
  *
  * Results:
  *	NULL if the channel is not stacked upon another one, or a reference
@@ -1655,20 +1411,22 @@ Tcl_Channel
 Tcl_GetStackedChannel(chan)
     Tcl_Channel chan;
 {
-  Channel* chanPtr = (Channel*) chan;
-  return (Tcl_Channel) chanPtr->supercedes;
+    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
+
+    return (Tcl_Channel) chanPtr->downChanPtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetChannelMode --
+ * Tcl_GetTopChannel --
  *
- *	Computes a mask indicating whether the channel is open for
- *	reading and writing.
+ *	Returns the top channel of a channel stack.
  *
  * Results:
- *	An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
+ *	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.
@@ -1676,28 +1434,24 @@ Tcl_GetStackedChannel(chan)
  *----------------------------------------------------------------------
  */
 
-int
-Tcl_GetChannelMode(chan)
-    Tcl_Channel chan;		/* The channel for which the mode is
-                                 * being computed. */
+Tcl_Channel
+Tcl_GetTopChannel(chan)
+    Tcl_Channel chan;
 {
-    Channel *chanPtr;		/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
 
-    chanPtr = (Channel *) chan;
-    return (chanPtr->flags & (TCL_READABLE | TCL_WRITABLE));
+    return (Tcl_Channel) chanPtr->state->topChanPtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetChannelName --
+ * Tcl_GetChannelInstanceData --
  *
- *	Returns the string identifying the channel name.
+ *	Returns the client data associated with a channel.
  *
  * Results:
- *	The string containing the channel name. This memory is
- *	owned by the generic layer and should not be modified by
- *	the caller.
+ *	The client data.
  *
  * Side effects:
  *	None.
@@ -1705,14 +1459,13 @@ Tcl_GetChannelMode(chan)
  *----------------------------------------------------------------------
  */
 
-char *
-Tcl_GetChannelName(chan)
-    Tcl_Channel chan;		/* The channel for which to return the name. */
+ClientData
+Tcl_GetChannelInstanceData(chan)
+    Tcl_Channel chan;		/* Channel for which to return client data. */
 {
-    Channel *chanPtr;		/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
 
-    chanPtr = (Channel *) chan;
-    return chanPtr->channelName;
+    return chanPtr->instanceData;
 }
 
 /*
@@ -1735,22 +1488,21 @@ Tcl_ChannelType *
 Tcl_GetChannelType(chan)
     Tcl_Channel chan;		/* The channel to return type for. */
 {
-    Channel *chanPtr;		/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
 
-    chanPtr = (Channel *) chan;
     return chanPtr->typePtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetChannelHandle --
+ * Tcl_GetChannelMode --
  *
- *	Returns an OS handle associated with a channel.
+ *	Computes a mask indicating whether the channel is open for
+ *	reading and writing.
  *
  * Results:
- *	Returns TCL_OK and places the handle in handlePtr, or returns
- *	TCL_ERROR on failure.
+ *	An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
  *
  * Side effects:
  *	None.
@@ -1759,33 +1511,27 @@ Tcl_GetChannelType(chan)
  */
 
 int
-Tcl_GetChannelHandle(chan, direction, handlePtr)
-    Tcl_Channel chan;		/* The channel to get file from. */
-    int direction;		/* TCL_WRITABLE or TCL_READABLE. */
-    ClientData *handlePtr;	/* Where to store handle */
+Tcl_GetChannelMode(chan)
+    Tcl_Channel chan;		/* The channel for which the mode is
+                                 * being computed. */
 {
-    Channel *chanPtr;		/* The actual channel. */
-    ClientData handle;
-    int result;
+    ChannelState *statePtr = ((Channel *) chan)->state;
+					/* State of actual channel. */
 
-    chanPtr = (Channel *) chan;
-    result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
-	    direction, &handle);
-    if (handlePtr) {
-	*handlePtr = handle;
-    }
-    return result;
+    return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE));
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetChannelInstanceData --
+ * Tcl_GetChannelName --
  *
- *	Returns the client data associated with a channel.
+ *	Returns the string identifying the channel name.
  *
  * Results:
- *	The client data.
+ *	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.
@@ -1793,14 +1539,50 @@ Tcl_GetChannelHandle(chan, direction, handlePtr)
  *----------------------------------------------------------------------
  */
 
-ClientData
-Tcl_GetChannelInstanceData(chan)
-    Tcl_Channel chan;		/* Channel for which to return client data. */
+char *
+Tcl_GetChannelName(chan)
+    Tcl_Channel chan;		/* The channel for which to return the name. */
+{
+    ChannelState *statePtr;	/* State of actual channel. */
+
+    statePtr = ((Channel *) chan)->state;
+    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(chan, direction, handlePtr)
+    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;
-    return chanPtr->instanceData;
+    chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
+	    direction, &handle);
+    if (handlePtr) {
+	*handlePtr = handle;
+    }
+    return result;
 }
 
 /*
@@ -1865,8 +1647,8 @@ AllocChannelBuffer(length)
  */
 
 static void
-RecycleBuffer(chanPtr, bufPtr, mustDiscard)
-    Channel *chanPtr;		/* Channel for which to recycle buffers. */
+RecycleBuffer(statePtr, bufPtr, mustDiscard)
+    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. */
@@ -1879,19 +1661,19 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
         ckfree((char *) bufPtr);
         return;
     }
-    
+
     /*
      * Only save buffers for the input queue if the channel is readable.
      */
     
-    if (chanPtr->flags & TCL_READABLE) {
-        if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
-            chanPtr->inQueueHead = bufPtr;
-            chanPtr->inQueueTail = bufPtr;
+    if (statePtr->flags & TCL_READABLE) {
+        if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+            statePtr->inQueueHead = bufPtr;
+            statePtr->inQueueTail = bufPtr;
             goto keepit;
         }
-        if (chanPtr->saveInBufPtr == (ChannelBuffer *) NULL) {
-            chanPtr->saveInBufPtr = bufPtr;
+        if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) {
+            statePtr->saveInBufPtr = bufPtr;
             goto keepit;
         }
     }
@@ -1900,9 +1682,9 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
      * Only save buffers for the output queue if the channel is writable.
      */
 
-    if (chanPtr->flags & TCL_WRITABLE) {
-        if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
-            chanPtr->curOutPtr = bufPtr;
+    if (statePtr->flags & TCL_WRITABLE) {
+        if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+            statePtr->curOutPtr = bufPtr;
             goto keepit;
         }
     }
@@ -1914,7 +1696,7 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
     ckfree((char *) bufPtr);
     return;
 
-keepit:
+    keepit:
     bufPtr->nextRemoved = BUFFER_PADDING;
     bufPtr->nextAdded = BUFFER_PADDING;
     bufPtr->nextPtr = (ChannelBuffer *) NULL;
@@ -1937,18 +1719,18 @@ keepit:
  */
 
 static void
-DiscardOutputQueued(chanPtr)
-    Channel *chanPtr;		/* The channel for which to discard output. */
+DiscardOutputQueued(statePtr)
+    ChannelState *statePtr;	/* ChannelState for which to discard output. */
 {
     ChannelBuffer *bufPtr;
     
-    while (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
-        bufPtr = chanPtr->outQueueHead;
-        chanPtr->outQueueHead = bufPtr->nextPtr;
-        RecycleBuffer(chanPtr, bufPtr, 0);
+    while (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
+        bufPtr = statePtr->outQueueHead;
+        statePtr->outQueueHead = bufPtr->nextPtr;
+        RecycleBuffer(statePtr, bufPtr, 0);
     }
-    chanPtr->outQueueHead = (ChannelBuffer *) NULL;
-    chanPtr->outQueueTail = (ChannelBuffer *) NULL;
+    statePtr->outQueueHead = (ChannelBuffer *) NULL;
+    statePtr->outQueueTail = (ChannelBuffer *) NULL;
 }
 
 /*
@@ -1969,16 +1751,16 @@ DiscardOutputQueued(chanPtr)
  */
 
 static int
-CheckForDeadChannel(interp, chanPtr)
+CheckForDeadChannel(interp, statePtr)
     Tcl_Interp *interp;		/* For error reporting (can be NULL) */
-    Channel    *chanPtr;	/* The channel to check. */
+    ChannelState *statePtr;	/* The channel state to check. */
 {
-    if (chanPtr->flags & CHANNEL_DEAD) {
+    if (statePtr->flags & CHANNEL_DEAD) {
         Tcl_SetErrno(EINVAL);
 	if (interp) {
 	    Tcl_AppendResult(interp,
-			     "unable to access channel: invalid channel",
-			     (char *) NULL);   
+		    "unable to access channel: invalid channel",
+		    (char *) NULL);   
 	}
 	return 1;
     }
@@ -2014,6 +1796,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
                                          * called from an asynchronous
                                          * flush callback. */
 {
+    ChannelState *statePtr = chanPtr->state;
+					/* State of the channel stack. */
     ChannelBuffer *bufPtr;		/* Iterates over buffered output
                                          * queue. */
     int toWrite;			/* Amount of output data in current
@@ -2032,7 +1816,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
      * all interpreters.
      */
     
-    if (CheckForDeadChannel(interp,chanPtr)) return -1;
+    if (CheckForDeadChannel(interp, statePtr)) return -1;
     
     /*
      * Loop over the queued buffers and attempt to flush as
@@ -2046,22 +1830,22 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
          * the current buffer is full, then move the current buffer to the
          * queue.
          */
-        
-        if (((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
-                (chanPtr->curOutPtr->nextAdded == chanPtr->curOutPtr->bufLength))
-                || ((chanPtr->flags & BUFFER_READY) &&
-                        (chanPtr->outQueueHead == (ChannelBuffer *) NULL))) {
-            chanPtr->flags &= (~(BUFFER_READY));
-            chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
-            if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
-                chanPtr->outQueueHead = chanPtr->curOutPtr;
+
+        if (((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+                (statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
+                || ((statePtr->flags & BUFFER_READY) &&
+                        (statePtr->outQueueHead == (ChannelBuffer *) NULL))) {
+            statePtr->flags &= (~(BUFFER_READY));
+            statePtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
+            if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+                statePtr->outQueueHead = statePtr->curOutPtr;
             } else {
-                chanPtr->outQueueTail->nextPtr = chanPtr->curOutPtr;
+                statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
             }
-            chanPtr->outQueueTail = chanPtr->curOutPtr;
-            chanPtr->curOutPtr = (ChannelBuffer *) NULL;
+            statePtr->outQueueTail = statePtr->curOutPtr;
+            statePtr->curOutPtr = (ChannelBuffer *) NULL;
         }
-        bufPtr = chanPtr->outQueueHead;
+        bufPtr = statePtr->outQueueHead;
 
         /*
          * If we are not being called from an async flush and an async
@@ -2069,7 +1853,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
          */
 
         if ((!calledFromAsyncFlush) &&
-                (chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+                (statePtr->flags & BG_FLUSH_SCHEDULED)) {
             return 0;
         }
 
@@ -2084,12 +1868,12 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
         /*
          * Produce the output on the channel.
          */
-        
+
         toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
         written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
                 (char *) bufPtr->buf + bufPtr->nextRemoved, toWrite,
 		&errorCode);
-            
+
 	/*
          * If the write failed completely attempt to start the asynchronous
          * flush mechanism and break out of this loop - do not attempt to
@@ -2119,8 +1903,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
 		 * that setting stdin to -blocking 0 has some effect on
 		 * the stdout when it's a tty channel (dup'ed underneath)
 		 */
-		if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
-		    chanPtr->flags |= BG_FLUSH_SCHEDULED;
+		if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
+		    statePtr->flags |= BG_FLUSH_SCHEDULED;
 		    UpdateInterest(chanPtr);
 		}
 		errorCode = 0;
@@ -2132,8 +1916,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
              */
 
             if (calledFromAsyncFlush) {
-                if (chanPtr->unreportedError == 0) {
-                    chanPtr->unreportedError = errorCode;
+                if (statePtr->unreportedError == 0) {
+                    statePtr->unreportedError = errorCode;
                 }
             } else {
                 Tcl_SetErrno(errorCode);
@@ -2148,7 +1932,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
              * currently queued.
              */
 
-            DiscardOutputQueued(chanPtr);
+            DiscardOutputQueued(statePtr);
             continue;
         } else {
 	    wroteSome = 1;
@@ -2161,11 +1945,11 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
          */
 
         if (bufPtr->nextRemoved == bufPtr->nextAdded) {
-            chanPtr->outQueueHead = bufPtr->nextPtr;
-            if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
-                chanPtr->outQueueTail = (ChannelBuffer *) NULL;
+            statePtr->outQueueHead = bufPtr->nextPtr;
+            if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+                statePtr->outQueueTail = (ChannelBuffer *) NULL;
             }
-            RecycleBuffer(chanPtr, bufPtr, 0);
+            RecycleBuffer(statePtr, bufPtr, 0);
         }
     }	/* Closes "while (1)". */
 
@@ -2176,13 +1960,13 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
      * pending data has been flushed at the system level.
      */
 
-    if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
+    if (statePtr->flags & BG_FLUSH_SCHEDULED) {
 	if (wroteSome) {
 	    return errorCode;
-	} else if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
-	    chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
+	} else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+	    statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
 	    (chanPtr->typePtr->watchProc)(chanPtr->instanceData,
-		    chanPtr->interestMask);
+		    statePtr->interestMask);
 	}
     }
 
@@ -2192,12 +1976,12 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
      * in the current output buffer.
      */
 
-    if ((chanPtr->flags & CHANNEL_CLOSED) && (chanPtr->refCount <= 0) &&
-            (chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
-            ((chanPtr->curOutPtr == (ChannelBuffer *) NULL) ||
-                    (chanPtr->curOutPtr->nextAdded ==
-                            chanPtr->curOutPtr->nextRemoved))) {
-        return CloseChannel(interp, chanPtr, errorCode);
+    if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
+            (statePtr->outQueueHead == (ChannelBuffer *) NULL) &&
+            ((statePtr->curOutPtr == (ChannelBuffer *) NULL) ||
+                    (statePtr->curOutPtr->nextAdded ==
+                            statePtr->curOutPtr->nextRemoved))) {
+	return CloseChannel(interp, chanPtr, errorCode);
     }
     return errorCode;
 }
@@ -2207,14 +1991,21 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
  *
  * CloseChannel --
  *
- *	Utility procedure to close a channel and free its associated
- *	resources.
+ *	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:
- *	0 on success or a POSIX error code if the operation failed.
+ *	1 if the channel was stacked, 0 otherwise.
  *
  * Side effects:
  *	May close the actual channel; may free memory.
+ *	May change the value of errno.
  *
  *----------------------------------------------------------------------
  */
@@ -2227,24 +2018,27 @@ CloseChannel(interp, chanPtr, errorCode)
 {
     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(chanPtr, 1);
+    DiscardInputQueued(statePtr, 1);
 
     /*
      * Discard a leftover buffer in the current output buffer field.
      */
 
-    if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
-        ckfree((char *) chanPtr->curOutPtr);
-        chanPtr->curOutPtr = (ChannelBuffer *) NULL;
+    if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
+        ckfree((char *) statePtr->curOutPtr);
+        statePtr->curOutPtr = (ChannelBuffer *) NULL;
     }
     
     /*
@@ -2252,7 +2046,7 @@ CloseChannel(interp, chanPtr, errorCode)
      * queued for output.
      */
 
-    if (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
+    if (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
         panic("TclFlush, closed channel: queued output left");
     }
 
@@ -2261,52 +2055,56 @@ CloseChannel(interp, chanPtr, errorCode)
      * output device.
      */
 
-    if ((chanPtr->outEofChar != 0) && (chanPtr->flags & TCL_WRITABLE)) {
+    if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) {
         int dummy;
         char c;
 
-        c = (char) chanPtr->outEofChar;
+        c = (char) statePtr->outEofChar;
         (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
     }
 
     /*
-     * Remove TCL_READABLE and TCL_WRITABLE from chanPtr->flags, so
-     * that close callbacks can not do input or output (assuming they
-     * squirreled the channel away in their clientData). This also
-     * prevents infinite loops if the callback calls any C API that
-     * could call FlushChannel.
+     * Remove this channel from of the list of all channels.
      */
-
-    chanPtr->flags &= (~(TCL_READABLE|TCL_WRITABLE));
-
-    Tcl_CutChannel ((Tcl_Channel) chanPtr);
+    Tcl_CutChannel((Tcl_Channel) chanPtr);
 
     /*
      * Close and free the channel driver state.
      */
-            
+
     if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
 	result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp);
     } else {
 	result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
 		0);
     }
-    
-    if (chanPtr->channelName != (char *) NULL) {
-        ckfree(chanPtr->channelName);
-    }
-    Tcl_FreeEncoding(chanPtr->encoding);
-    if (chanPtr->outputStage != NULL) {
-	ckfree((char *) chanPtr->outputStage);
+
+    /*
+     * 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 != (char *) NULL) {
+	    ckfree(statePtr->channelName);
+	    statePtr->channelName = NULL;
+	}
+
+	Tcl_FreeEncoding(statePtr->encoding);
+	if (statePtr->outputStage != NULL) {
+	    ckfree((char *) statePtr->outputStage);
+	    statePtr->outputStage = (char *) NULL;
+	}
     }
-    
+
     /*
      * If we are being called synchronously, report either
      * any latent error on the channel or the current error.
      */
-        
-    if (chanPtr->unreportedError != 0) {
-        errorCode = chanPtr->unreportedError;
+
+    if (statePtr->unreportedError != 0) {
+        errorCode = statePtr->unreportedError;
     }
     if (errorCode == 0) {
         errorCode = result;
@@ -2315,51 +2113,34 @@ CloseChannel(interp, chanPtr, errorCode)
         }
     }
 
-    /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998
-     * "Trf-Patch for filtering channels"
-     *
-     * This is the change to 'CloseChannel'.
-     *
-     * Explanation
-     *		Closing a filtering channel closes the one it
-     *		superceded too. This basically ripples through
-     *		the whole chain of filters until it reaches
-     *		the underlying normal channel.
-     *
-     *		This is done by reintegrating the superceded
-     *		channel into the (thread) global list of open
-     *		channels and then invoking a regular close.
-     *		There is no need to handle the complexities of
-     *		this process by ourselves.
-     *
-     *		*Note*
-     *		This has to be done after the call to the
-     *		'closeProc' of the filtering channel to allow
-     *		that one to flush internal buffers into
-     *		the underlying channel.
-     */
-
-    if (chanPtr->supercedes != (Channel*) NULL) {
-	/*
-	 * Insert the channel we were stacked upon back into
-	 * the list of open channels, then do a regular close.
-	 */
-
-        Tcl_SpliceChannel ((Tcl_Channel) chanPtr->supercedes);
-	chanPtr->supercedes->refCount --; /* is deregistered */
-	Tcl_Close (interp, (Tcl_Channel) chanPtr->supercedes);
-    }
-
     /*
      * Cancel any outstanding timer.
      */
 
-    Tcl_DeleteTimerHandler(chanPtr->timer);
+    Tcl_DeleteTimerHandler(statePtr->timer);
 
     /*
      * Mark the channel as deleted by clearing the type structure.
      */
 
+    if (chanPtr->downChanPtr != (Channel *) NULL) {
+	Channel *downChanPtr = chanPtr->downChanPtr;
+
+	statePtr->nextCSPtr	= tsdPtr->firstCSPtr;
+	tsdPtr->firstCSPtr	= statePtr;
+
+	statePtr->topChanPtr	= downChanPtr;
+	downChanPtr->upChanPtr	= (Channel *) NULL;
+	chanPtr->typePtr	= NULL;
+
+	Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+	return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
+    }
+
+    /*
+     * There is only the TOP Channel, so we free the remaining
+     * pointers we have and then ourselves.
+     */
     chanPtr->typePtr = NULL;
 
     Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
@@ -2373,19 +2154,20 @@ CloseChannel(interp, chanPtr, errorCode)
  * Tcl_CutChannel --
  *
  *	Removes a channel from the (thread-)global list of all channels
- *	(in that thread).
+ *	(in that thread).  This is actually the statePtr for the stack
+ *	of channel.
  *
  * Results:
  *	Nothing.
  *
  * Side effects:
- *	Resets the field 'nextChanPtr' of the specified channel to NULL.
+ *	Resets the field 'nextCSPtr' of the specified channel state to NULL.
  *
  * NOTE:
  *	The channel to splice 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
- *	figgle with the channel (like transfering it to a different
+ *	fiddle with the channel (like transfering it to a different
  *	thread) and thus keeps the refcount artifically high to prevent
  *	its destruction.
  *
@@ -2393,38 +2175,38 @@ CloseChannel(interp, chanPtr, errorCode)
  */
 
 void
-Tcl_CutChannel (chan)
+Tcl_CutChannel(chan)
     Tcl_Channel chan;			/* The channel being removed. Must
                                          * not be referenced in any
                                          * interpreter. */
 {
     ThreadSpecificData* tsdPtr  = TCL_TSD_INIT(&dataKey);
-    Channel*            chanPtr = (Channel *) chan;
-    Channel*            prevChanPtr;	/* Preceding channel in list of
-                                         * all channels - used to splice a
+    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. */
 
     /*
-     * Splice this channel out of the list of all channels (in the current
-     * thread).
+     * Remove this channel from of the list of all channels
+     * (in the current thread).
      */
 
-    if (chanPtr == tsdPtr->firstChanPtr) {
-        tsdPtr->firstChanPtr = chanPtr->nextChanPtr;
+    if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
+        tsdPtr->firstCSPtr = statePtr->nextCSPtr;
     } else {
-        for (prevChanPtr = tsdPtr->firstChanPtr;
-                 (prevChanPtr != (Channel *) NULL) &&
-                     (prevChanPtr->nextChanPtr != chanPtr);
-                 prevChanPtr = prevChanPtr->nextChanPtr) {
+        for (prevCSPtr = tsdPtr->firstCSPtr;
+	     prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+	     prevCSPtr = prevCSPtr->nextCSPtr) {
             /* Empty loop body. */
         }
-        if (prevChanPtr == (Channel *) NULL) {
+        if (prevCSPtr == (ChannelState *) NULL) {
             panic("FlushChannel: damaged channel list");
         }
-        prevChanPtr->nextChanPtr = chanPtr->nextChanPtr;
+        prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
     }
 
-    chanPtr->nextChanPtr = (Channel *) NULL;
+    statePtr->nextCSPtr = (ChannelState *) NULL;
 }
 
 /*
@@ -2454,20 +2236,20 @@ Tcl_CutChannel (chan)
  */
 
 void
-Tcl_SpliceChannel (chan)
+Tcl_SpliceChannel(chan)
     Tcl_Channel chan;			/* The channel being added. Must
                                          * not be referenced in any
                                          * interpreter. */
 {
-    ThreadSpecificData* tsdPtr  = TCL_TSD_INIT(&dataKey);
-    Channel*            chanPtr = (Channel *) chan;
+    ThreadSpecificData	*tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelState	*statePtr = ((Channel *) chan)->state;
 
-    if (chanPtr->nextChanPtr != (Channel *) NULL) {
+    if (statePtr->nextCSPtr != (ChannelState *) NULL) {
         panic("Tcl_SpliceChannel: trying to add channel used in different list");
     }
 
-    chanPtr->nextChanPtr = tsdPtr->firstChanPtr;
-    tsdPtr->firstChanPtr = chanPtr;
+    statePtr->nextCSPtr	= tsdPtr->firstCSPtr;
+    tsdPtr->firstCSPtr	= statePtr;
 }
 
 /*
@@ -2503,12 +2285,13 @@ Tcl_Close(interp, chan)
     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. */
 
     if (chan == (Tcl_Channel) 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
@@ -2519,20 +2302,27 @@ Tcl_Close(interp, chan)
 
     CheckForStdChannelsBeingClosed(chan);
 
-    chanPtr = (Channel *) chan;
-    if (chanPtr->refCount > 0) {
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr	= (Channel *) chan;
+    statePtr	= chanPtr->state;
+    chanPtr	= statePtr->topChanPtr;
+
+    if (statePtr->refCount > 0) {
         panic("called Tcl_Close on channel with refCount > 0");
     }
 
-    Tcl_ClearChannelHandlers (chan);
-        
+    Tcl_ClearChannelHandlers(chan);
+
     /*
      * Invoke the registered close callbacks and delete their records.
      */
 
-    while (chanPtr->closeCbPtr != (CloseCallback *) NULL) {
-        cbPtr = chanPtr->closeCbPtr;
-        chanPtr->closeCbPtr = cbPtr->nextPtr;
+    while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
+        cbPtr = statePtr->closeCbPtr;
+        statePtr->closeCbPtr = cbPtr->nextPtr;
         (cbPtr->proc) (cbPtr->clientData);
         ckfree((char *) cbPtr);
     }
@@ -2541,9 +2331,9 @@ Tcl_Close(interp, chan)
      * Ensure that the last output buffer will be flushed.
      */
     
-    if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
-           (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
-        chanPtr->flags |= BUFFER_READY;
+    if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+	    (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+        statePtr->flags |= BUFFER_READY;
     }
 
     /*
@@ -2564,7 +2354,7 @@ Tcl_Close(interp, chan)
      * channel to be flushed and closed asynchronously.
      */
 
-    chanPtr->flags |= CHANNEL_CLOSED;
+    statePtr->flags |= CHANNEL_CLOSED;
     if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) {
         return TCL_ERROR;
     }
@@ -2596,10 +2386,17 @@ Tcl_ClearChannelHandlers (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;
 
-    chanPtr = (Channel *) channel;
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr	= (Channel *) channel;
+    statePtr	= chanPtr->state;
+    chanPtr	= statePtr->topChanPtr;
 
     /*
      * Remove any references to channel handlers for this channel that
@@ -2607,8 +2404,8 @@ Tcl_ClearChannelHandlers (channel)
      */
 
     for (nhPtr = tsdPtr->nestedHandlerPtr;
-             nhPtr != (NextChannelHandler *) NULL;
-             nhPtr = nhPtr->nestedHandlerPtr) {
+	 nhPtr != (NextChannelHandler *) NULL;
+	 nhPtr = nhPtr->nestedHandlerPtr) {
         if (nhPtr->nextHandlerPtr &&
 		(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
 	    nhPtr->nextHandlerPtr = NULL;
@@ -2619,21 +2416,20 @@ Tcl_ClearChannelHandlers (channel)
      * Remove all the channel handler records attached to the channel
      * itself.
      */
-        
-    for (chPtr = chanPtr->chPtr;
-             chPtr != (ChannelHandler *) NULL;
-             chPtr = chNext) {
+
+    for (chPtr = statePtr->chPtr;
+	 chPtr != (ChannelHandler *) NULL;
+	 chPtr = chNext) {
         chNext = chPtr->nextPtr;
         ckfree((char *) chPtr);
     }
-    chanPtr->chPtr = (ChannelHandler *) NULL;
-    
-    
+    statePtr->chPtr = (ChannelHandler *) NULL;
+
     /*
      * Cancel any pending copy operation.
      */
 
-    StopCopy(chanPtr->csPtr);
+    StopCopy(statePtr->csPtr);
 
     /*
      * Must set the interest mask now to 0, otherwise infinite loops
@@ -2642,20 +2438,20 @@ Tcl_ClearChannelHandlers (channel)
      * has a background flush active.
      */
         
-    chanPtr->interestMask = 0;
+    statePtr->interestMask = 0;
     
     /*
      * Remove any EventScript records for this channel.
      */
 
-    for (ePtr = chanPtr->scriptRecordPtr;
-             ePtr != (EventScriptRecord *) NULL;
-             ePtr = eNextPtr) {
+    for (ePtr = statePtr->scriptRecordPtr;
+	 ePtr != (EventScriptRecord *) NULL;
+	 ePtr = eNextPtr) {
         eNextPtr = ePtr->nextPtr;
 	Tcl_DecrRefCount(ePtr->scriptPtr);
         ckfree((char *) ePtr);
     }
-    chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+    statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
 }
 
 /*
@@ -2686,12 +2482,19 @@ Tcl_Write(chan, src, srcLen)
     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 */
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+    statePtr = ((Channel *) chan)->state;
+    chanPtr  = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return -1;
     }
+
     if (srcLen < 0) {
         srcLen = strlen(src);
     }
@@ -2699,6 +2502,61 @@ Tcl_Write(chan, src, 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.
+ *
+ * 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(chan, src, srcLen)
+    Tcl_Channel chan;			/* The channel to buffer output for. */
+    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 = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
+	    src, srcLen, &errorCode);
+
+    if (written < 0) {
+	Tcl_SetErrno(errorCode);
+    }
+
+    return written;
+}
+
+/*
  *---------------------------------------------------------------------------
  *
  * Tcl_WriteChars --
@@ -2727,16 +2585,22 @@ Tcl_WriteChars(chan, src, len)
     int len;			/* Length of string in bytes, or < 0 for 
 				 * strlen(). */
 {
+    /*
+     * Always use the topmost channel of the stack
+     */
     Channel *chanPtr;
+    ChannelState *statePtr;	/* state info for channel */
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+    statePtr = ((Channel *) chan)->state;
+    chanPtr  = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return -1;
     }
     if (len < 0) {
         len = strlen(src);
     }
-    if (chanPtr->encoding == NULL) {
+    if (statePtr->encoding == NULL) {
 	/*
 	 * Inefficient way to convert UTF-8 to byte-array, but the  
 	 * code parallels the way it is done for objects.
@@ -2784,15 +2648,21 @@ Tcl_WriteObj(chan, objPtr)
     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 */
     char *src;
     int srcLen;
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+    statePtr = ((Channel *) chan)->state;
+    chanPtr  = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return -1;
     }
-    if (chanPtr->encoding == NULL) {
+    if (statePtr->encoding == NULL) {
 	src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
 	return WriteBytes(chanPtr, src, srcLen);
     } else {
@@ -2828,6 +2698,7 @@ WriteBytes(chanPtr, src, srcLen)
     CONST char *src;		/* Bytes to write. */
     int srcLen;			/* Number of bytes to write. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
     char *dst;
     int dstLen, dstMax, sawLF, savedLF, total, toWrite;
@@ -2842,10 +2713,10 @@ WriteBytes(chanPtr, src, srcLen)
      */
 
     while (srcLen + savedLF > 0) {
-	bufPtr = chanPtr->curOutPtr;
+	bufPtr = statePtr->curOutPtr;
 	if (bufPtr == NULL) {
-	    bufPtr = AllocChannelBuffer(chanPtr->bufSize);
-	    chanPtr->curOutPtr	= bufPtr;
+	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
+	    statePtr->curOutPtr	= bufPtr;
 	}
 	dst = bufPtr->buf + bufPtr->nextAdded;
 	dstMax = bufPtr->bufLength - bufPtr->nextAdded;
@@ -2867,7 +2738,7 @@ WriteBytes(chanPtr, src, srcLen)
 	    dstLen--;
 	    sawLF++;
 	}
-	sawLF += TranslateOutputEOL(chanPtr, dst, src, &dstLen, &toWrite);
+	sawLF += TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite);
 	dstLen += savedLF;
 	savedLF = 0;
 
@@ -2915,6 +2786,7 @@ WriteChars(chanPtr, src, srcLen)
     CONST char *src;		/* UTF-8 string to write. */
     int srcLen;			/* Length of UTF-8 string in bytes. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
     char *dst, *stage;
     int saved, savedLF, sawLF, total, toWrite, flags;
@@ -2926,7 +2798,7 @@ WriteChars(chanPtr, src, srcLen)
     sawLF = 0;
     savedLF = 0;
     saved = 0;
-    encoding = chanPtr->encoding;
+    encoding = statePtr->encoding;
 
     /*
      * Loop over all UTF-8 characters in src, storing them in staging buffer
@@ -2934,8 +2806,8 @@ WriteChars(chanPtr, src, srcLen)
      */
 
     while (srcLen + savedLF > 0) {
-	stage = chanPtr->outputStage;
-	stageMax = chanPtr->bufSize;
+	stage = statePtr->outputStage;
+	stageMax = statePtr->bufSize;
 	stageLen = stageMax;
 
 	toWrite = stageLen;
@@ -2955,7 +2827,7 @@ WriteChars(chanPtr, src, srcLen)
 	    stageLen--;
 	    sawLF++;
 	}
-	sawLF += TranslateOutputEOL(chanPtr, stage, src, &stageLen, &toWrite);
+	sawLF += TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite);
 
 	stage -= savedLF;
 	stageLen += savedLF;
@@ -2968,7 +2840,7 @@ WriteChars(chanPtr, src, srcLen)
 	src += toWrite;
 	srcLen -= toWrite;
 
-	flags = chanPtr->outputEncodingFlags;
+	flags = statePtr->outputEncodingFlags;
 	if (srcLen == 0) {
 	    flags |= TCL_ENCODING_END;
 	}
@@ -2979,10 +2851,10 @@ WriteChars(chanPtr, src, srcLen)
 	 */
 
 	while (stageLen + saved > 0) {
-	    bufPtr = chanPtr->curOutPtr;
+	    bufPtr = statePtr->curOutPtr;
 	    if (bufPtr == NULL) {
-		bufPtr = AllocChannelBuffer(chanPtr->bufSize);
-		chanPtr->curOutPtr = bufPtr;
+		bufPtr = AllocChannelBuffer(statePtr->bufSize);
+		statePtr->curOutPtr = bufPtr;
 	    }
 	    dst = bufPtr->buf + bufPtr->nextAdded;
 	    dstLen = bufPtr->bufLength - bufPtr->nextAdded;
@@ -3002,7 +2874,7 @@ WriteChars(chanPtr, src, srcLen)
 	    }
 
 	    Tcl_UtfToExternal(NULL, encoding, stage, stageLen, flags,
-		    &chanPtr->outputEncodingState, dst,
+		    &statePtr->outputEncodingState, dst,
 		    dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
 	    if (stageRead + dstWrote == 0) {
 		/*
@@ -3086,8 +2958,8 @@ WriteChars(chanPtr, src, srcLen)
  */
 
 static int
-TranslateOutputEOL(chanPtr, dst, src, dstLenPtr, srcLenPtr)
-    Channel *chanPtr;		/* Channel being read, for translation and
+TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
+    ChannelState *statePtr;	/* Channel being read, for translation and
 				 * buffering modes. */
     char *dst;			/* Output buffer filled with UTF-8 chars by
 				 * applying appropriate EOL translation to
@@ -3106,7 +2978,7 @@ TranslateOutputEOL(chanPtr, dst, src, dstLenPtr, srcLenPtr)
     newlineFound = 0;
     srcLen = *srcLenPtr;
 
-    switch (chanPtr->outputTranslation) {
+    switch (statePtr->outputTranslation) {
 	case TCL_TRANSLATE_LF: {
 	    for (dstEnd = dst + srcLen; dst < dstEnd; ) {
 		if (*src == '\n') {
@@ -3198,6 +3070,7 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
     int newlineFlag;		/* Non-zero if a the channel buffer
 				 * contains a newline. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     /*
      * The current buffer is ready for output:
      * 1. if it is full.
@@ -3205,18 +3078,18 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
      * 3. if it contains any output and this channel is unbuffered.
      */
 
-    if ((chanPtr->flags & BUFFER_READY) == 0) {
+    if ((statePtr->flags & BUFFER_READY) == 0) {
 	if (bufPtr->nextAdded == bufPtr->bufLength) {
-	    chanPtr->flags |= BUFFER_READY;
-	} else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
+	    statePtr->flags |= BUFFER_READY;
+	} else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
 	    if (newlineFlag != 0) {
-		chanPtr->flags |= BUFFER_READY;
+		statePtr->flags |= BUFFER_READY;
 	    }
-	} else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
-	    chanPtr->flags |= BUFFER_READY;
+	} else if (statePtr->flags & CHANNEL_UNBUFFERED) {
+	    statePtr->flags |= BUFFER_READY;
 	}
     }
-    if (chanPtr->flags & BUFFER_READY) {
+    if (statePtr->flags & BUFFER_READY) {
 	if (FlushChannel(NULL, chanPtr, 0) != 0) {
 	    return -1;
 	}
@@ -3297,22 +3170,28 @@ Tcl_GetsObj(chan, objPtr)
 				 * object as UTF-8 characters. */
 {
     GetsState gs;
-    Channel *chanPtr;
-    int inEofChar, skip, copiedTotal;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
+    int inEofChar, skip, copiedTotal;
     Tcl_Encoding encoding;
     char *dst, *dstEnd, *eol, *eof;
     Tcl_EncodingState oldState;
     int oldLength, oldFlags, oldRemoved;
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
 	copiedTotal = -1;
 	goto done;
     }
 
-    bufPtr = chanPtr->inQueueHead;
-    encoding = chanPtr->encoding;
+    bufPtr = statePtr->inQueueHead;
+    encoding = statePtr->encoding;
 
     /*
      * Preserved so we can restore the channel's state in case we don't
@@ -3320,8 +3199,8 @@ Tcl_GetsObj(chan, objPtr)
      */
 
     Tcl_GetStringFromObj(objPtr, &oldLength);
-    oldFlags = chanPtr->inputEncodingFlags;
-    oldState = chanPtr->inputEncodingState;
+    oldFlags = statePtr->inputEncodingFlags;
+    oldState = statePtr->inputEncodingState;
     oldRemoved = BUFFER_PADDING;
     if (bufPtr != NULL) {
 	oldRemoved = bufPtr->nextRemoved;
@@ -3357,7 +3236,7 @@ Tcl_GetsObj(chan, objPtr)
 
     skip = 0;
     eof = NULL;
-    inEofChar = chanPtr->inEofChar;
+    inEofChar = statePtr->inEofChar;
 
     while (1) {
 	if (dst >= dstEnd) {
@@ -3388,7 +3267,7 @@ Tcl_GetsObj(chan, objPtr)
 	 */
 
 	eol = dst;
-	switch (chanPtr->inputTranslation) {
+	switch (statePtr->inputTranslation) {
 	    case TCL_TRANSLATE_LF: {
 		for (eol = dst; eol < dstEnd; eol++) {
 		    if (*eol == '\n') {
@@ -3437,8 +3316,8 @@ Tcl_GetsObj(chan, objPtr)
 	    }
 	    case TCL_TRANSLATE_AUTO: {
 		skip = 1;
-		if (chanPtr->flags & INPUT_SAW_CR) {
-		    chanPtr->flags &= ~INPUT_SAW_CR;
+		if (statePtr->flags & INPUT_SAW_CR) {
+		    statePtr->flags &= ~INPUT_SAW_CR;
 		    if (*eol == '\n') {
 			/*
 			 * Skip the raw bytes that make up the '\n'.
@@ -3450,7 +3329,7 @@ Tcl_GetsObj(chan, objPtr)
 			bufPtr = gs.bufPtr;
 			Tcl_ExternalToUtf(NULL, gs.encoding,
 				bufPtr->buf + bufPtr->nextRemoved,
-				gs.rawRead, chanPtr->inputEncodingFlags,
+				gs.rawRead, statePtr->inputEncodingFlags,
 				&gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead,
 				NULL, NULL);
 			bufPtr->nextRemoved += rawRead;
@@ -3478,7 +3357,7 @@ Tcl_GetsObj(chan, objPtr)
 			    eol = objPtr->bytes + offset;
 			    if (eol >= dstEnd) {
 				eol--;
-				chanPtr->flags |= INPUT_SAW_CR;
+				statePtr->flags |= INPUT_SAW_CR;
 				goto goteol;
 			    }
 			}
@@ -3501,10 +3380,10 @@ Tcl_GetsObj(chan, objPtr)
 	     */
 
 	    dstEnd = eof;
-	    chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
-	    chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+	    statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_END;
 	}
-	if (chanPtr->flags & CHANNEL_EOF) {
+	if (statePtr->flags & CHANNEL_EOF) {
 	    skip = 0;
 	    eol = dstEnd;
 	    if (eol == objPtr->bytes) {
@@ -3533,10 +3412,10 @@ Tcl_GetsObj(chan, objPtr)
      
     goteol:
     bufPtr = gs.bufPtr;
-    chanPtr->inputEncodingState = gs.state;
+    statePtr->inputEncodingState = gs.state;
     Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved,
-	    gs.rawRead, chanPtr->inputEncodingFlags,
-	    &chanPtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX,
+	    gs.rawRead, statePtr->inputEncodingFlags,
+	    &statePtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX,
 	    &gs.rawRead, NULL, &gs.charsWrote);
     bufPtr->nextRemoved += gs.rawRead;
 
@@ -3546,7 +3425,7 @@ Tcl_GetsObj(chan, objPtr)
 
     Tcl_SetObjLength(objPtr, eol - objPtr->bytes);
     CommonGetsCleanup(chanPtr, encoding);
-    chanPtr->flags &= ~CHANNEL_BLOCKED;
+    statePtr->flags &= ~CHANNEL_BLOCKED;
     copiedTotal = gs.totalChars + gs.charsWrote - skip;
     goto done;
 
@@ -3557,7 +3436,7 @@ Tcl_GetsObj(chan, objPtr)
      */
 
     restore:
-    bufPtr = chanPtr->inQueueHead;
+    bufPtr = statePtr->inQueueHead;
     bufPtr->nextRemoved = oldRemoved;
 
     for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
@@ -3565,8 +3444,8 @@ Tcl_GetsObj(chan, objPtr)
     }
     CommonGetsCleanup(chanPtr, encoding);
 
-    chanPtr->inputEncodingState = oldState;
-    chanPtr->inputEncodingFlags = oldFlags;
+    statePtr->inputEncodingState = oldState;
+    statePtr->inputEncodingFlags = oldFlags;
     Tcl_SetObjLength(objPtr, oldLength);
 
     /*
@@ -3580,7 +3459,7 @@ Tcl_GetsObj(chan, objPtr)
      * though a read would be able to consume the buffered data.
      */
 
-    chanPtr->flags |= CHANNEL_NEED_MORE_DATA;
+    statePtr->flags |= CHANNEL_NEED_MORE_DATA;
     copiedTotal = -1;
 
     done:
@@ -3622,6 +3501,7 @@ FilterInputBytes(chanPtr, gsPtr)
     Channel *chanPtr;		/* Channel to read. */
     GetsState *gsPtr;		/* Current state of gets operation. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
     char *raw, *rawStart, *rawEnd;
     char *dst;
@@ -3658,20 +3538,20 @@ FilterInputBytes(chanPtr, gsPtr)
 	 */
 	 
 	read:
-        if (chanPtr->flags & CHANNEL_BLOCKED) {
-            if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+        if (statePtr->flags & CHANNEL_BLOCKED) {
+            if (statePtr->flags & CHANNEL_NONBLOCKING) {
 		gsPtr->charsWrote = 0;
 		gsPtr->rawRead = 0;
 		return -1;
 	    }
-            chanPtr->flags &= ~CHANNEL_BLOCKED;
+            statePtr->flags &= ~CHANNEL_BLOCKED;
         }
 	if (GetInput(chanPtr) != 0) {
 	    gsPtr->charsWrote = 0;
 	    gsPtr->rawRead = 0;
 	    return -1;
 	}
-	bufPtr = chanPtr->inQueueTail;
+	bufPtr = statePtr->inQueueTail;
 	gsPtr->bufPtr = bufPtr;
     }
 
@@ -3705,9 +3585,9 @@ FilterInputBytes(chanPtr, gsPtr)
 	dst = objPtr->bytes + offset;
 	*gsPtr->dstPtr = dst;
     }
-    gsPtr->state = chanPtr->inputEncodingState;
+    gsPtr->state = statePtr->inputEncodingState;
     result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen,
-	    chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+	    statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
 	    dst, spaceLeft, &gsPtr->rawRead, &gsPtr->bytesWrote,
 	    &gsPtr->charsWrote); 
     if (result == TCL_CONVERT_MULTIBYTE) {
@@ -3728,13 +3608,13 @@ FilterInputBytes(chanPtr, gsPtr)
 		 * returning those UTF-8 characters because a EOL might be
 		 * present in them.
 		 */
-	    } else if (chanPtr->flags & CHANNEL_EOF) {
+	    } else if (statePtr->flags & CHANNEL_EOF) {
 		/*
 		 * There was a partial character followed by EOF on the
 		 * device.  Fall through, returning that nothing was found.
 		 */
 
-		 bufPtr->nextRemoved = bufPtr->nextAdded;
+		bufPtr->nextRemoved = bufPtr->nextAdded;
 	    } else {
 		/*
 		 * There are no more cached raw bytes left.  See if we can
@@ -3745,9 +3625,9 @@ FilterInputBytes(chanPtr, gsPtr)
 	    }
 	} else {
 	    if (nextPtr == NULL) {
-		nextPtr = AllocChannelBuffer(chanPtr->bufSize);
+		nextPtr = AllocChannelBuffer(statePtr->bufSize);
 		bufPtr->nextPtr = nextPtr;
-		chanPtr->inQueueTail = nextPtr;
+		statePtr->inQueueTail = nextPtr;
 	    }
 	    extra = rawLen - gsPtr->rawRead;
 	    memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
@@ -3790,6 +3670,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
 				 * 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;
@@ -3815,8 +3696,8 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
 		 
 		goto cleanup;
 	    }
-	    if ((chanPtr->flags & CHANNEL_NONBLOCKING) == 0) {
-		blockModeProc = chanPtr->typePtr->blockModeProc;
+	    if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) {
+		blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
 		if (blockModeProc == NULL) {
 		    /*
 		     * Don't peek ahead if cannot set non-blocking mode.
@@ -3824,7 +3705,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
 
 		    goto cleanup;
 		}
-		(*blockModeProc)(chanPtr->instanceData, TCL_MODE_NONBLOCKING);
+		StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
 	    }
 	}
     }
@@ -3832,7 +3713,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
 	*dstEndPtr = *gsPtr->dstPtr + gsPtr->bytesWrote;
     }
     if (blockModeProc != NULL) {
-	(*blockModeProc)(chanPtr->instanceData, TCL_MODE_BLOCKING);
+	StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
     }
     return;
 
@@ -3866,19 +3747,20 @@ CommonGetsCleanup(chanPtr, encoding)
     Channel *chanPtr;
     Tcl_Encoding encoding;
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr, *nextPtr;
     
-    bufPtr = chanPtr->inQueueHead;
+    bufPtr = statePtr->inQueueHead;
     for ( ; bufPtr != NULL; bufPtr = nextPtr) {
 	nextPtr = bufPtr->nextPtr;
 	if (bufPtr->nextRemoved < bufPtr->nextAdded) {
 	    break;
 	}
-	RecycleBuffer(chanPtr, bufPtr, 0);
+	RecycleBuffer(statePtr, bufPtr, 0);
     }
-    chanPtr->inQueueHead = bufPtr;
+    statePtr->inQueueHead = bufPtr;
     if (bufPtr == NULL) {
-	chanPtr->inQueueTail = NULL;
+	statePtr->inQueueTail = NULL;
     } else {
 	/*
 	 * If any multi-byte characters were split across channel buffer
@@ -3904,7 +3786,7 @@ CommonGetsCleanup(chanPtr, encoding)
 	    bufPtr = nextPtr;
 	}
     }
-    if (chanPtr->encoding == NULL) {
+    if (statePtr->encoding == NULL) {
 	Tcl_FreeEncoding(encoding);
     }
 }
@@ -3937,10 +3819,16 @@ Tcl_Read(chan, dst, bytesToRead)
     char *dst;			/* Where to store input read. */
     int bytesToRead;		/* Maximum number of bytes to read. */
 {
-    Channel *chanPtr;		
-    
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+    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;
     }
 
@@ -3948,6 +3836,127 @@ Tcl_Read(chan, dst, bytesToRead)
 }
 
 /*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ReadRaw --
+ *
+ *	Reads a given number of bytes from a channel.  EOL and EOF
+ *	translation is done on the bytes being read, so the 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(chan, bufPtr, bytesToRead)
+    Tcl_Channel chan;		/* The channel from which to read. */
+    char *bufPtr;			/* 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 nread, result;
+    int copied, copiedNow;
+
+    /*
+     * The check below does too much because it will reject a call to this
+     * function with a channel which is part of an 'fcopy'. But we have to
+     * allow this here or else the chaining in the transformation drivers
+     * will fail with 'file busy' error instead of retrieving and
+     * transforming the data to copy.
+     *
+     * We let the check procedure now believe that there is no fcopy in
+     * progress. A better solution than this might be an additional flag
+     * argument to switch off specific checks.
+     */
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) {
+	return -1;
+    }
+
+    /*
+     * Check for information in the push-back buffers. If there is
+     * some, use it. Go to the driver only if there is none (anymore)
+     * and the caller requests more bytes.
+     */
+
+    for (copied = 0; copied < bytesToRead; copied += copiedNow) {
+        copiedNow = CopyBuffer(chanPtr, bufPtr + copied,
+                bytesToRead - copied);
+        if (copiedNow == 0) {
+            if (statePtr->flags & CHANNEL_EOF) {
+		goto done;
+            }
+            if (statePtr->flags & CHANNEL_BLOCKED) {
+                if (statePtr->flags & CHANNEL_NONBLOCKING) {
+		    goto done;
+                }
+                statePtr->flags &= (~(CHANNEL_BLOCKED));
+            }
+
+	    /*
+	     * Now go to the driver to get as much as is possible to
+	     * fill the remaining request. Do all the error handling
+	     * by ourselves.  The code was stolen from 'GetInput' and
+	     * slightly adapted (different return value here).
+	     *
+	     * The case of 'bytesToRead == 0' at this point cannot happen.
+	     */
+
+	    nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+			  bufPtr + copied, bytesToRead - copied, &result);
+	    if (nread > 0) {
+	        /*
+		 * If we get a short read, signal up that we may be
+		 * BLOCKED. We should avoid calling the driver because
+		 * on some platforms we will block in the low level
+		 * reading code even though the channel is set into
+		 * nonblocking mode.
+		 */
+            
+	        if (nread < (bytesToRead - copied)) {
+		    statePtr->flags |= CHANNEL_BLOCKED;
+		}
+	    } else if (nread == 0) {
+	        statePtr->flags |= CHANNEL_EOF;
+		statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+	    } else if (nread < 0) {
+	        if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
+		    if (copied > 0) {
+		      /*
+		       * Information that was copied earlier has precedence
+		       * over EAGAIN/WOULDBLOCK handling.
+		       */
+		      return copied;
+		    }
+
+		    statePtr->flags |= CHANNEL_BLOCKED;
+		    result = EAGAIN;
+		}
+
+		Tcl_SetErrno(result);
+		return -1;
+	    } 
+
+	    return copied + nread;
+        }
+    }
+
+done:
+    return copied;
+}
+
+/*
  *---------------------------------------------------------------------------
  *
  * Tcl_ReadChars --
@@ -3982,19 +3991,25 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
 				 * of the object. */
 
 {
-    Channel *chanPtr;
-    int offset, factor, copied, copiedNow, result;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
+    int offset, factor, copied, copiedNow, result;
     Tcl_Encoding encoding;
 #define UTF_EXPANSION_FACTOR	1024
     
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
 	copied = -1;
 	goto done;
     }
 
-    encoding = chanPtr->encoding;
+    encoding = statePtr->encoding;
     factor = UTF_EXPANSION_FACTOR;
 
     if (appendFlag == 0) {
@@ -4014,11 +4029,11 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
 
     for (copied = 0; (unsigned) toRead > 0; ) {
 	copiedNow = -1;
-	if (chanPtr->inQueueHead != NULL) {
+	if (statePtr->inQueueHead != NULL) {
 	    if (encoding == NULL) {
-		copiedNow = ReadBytes(chanPtr, objPtr, toRead, &offset);
+		copiedNow = ReadBytes(statePtr, objPtr, toRead, &offset);
 	    } else {
-		copiedNow = ReadChars(chanPtr, objPtr, toRead, &offset,
+		copiedNow = ReadChars(statePtr, objPtr, toRead, &offset,
 			&factor);
 	    }
 
@@ -4026,27 +4041,27 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
 	     * If the current buffer is empty recycle it.
 	     */
 
-	    bufPtr = chanPtr->inQueueHead;
+	    bufPtr = statePtr->inQueueHead;
 	    if (bufPtr->nextRemoved == bufPtr->nextAdded) {
 		ChannelBuffer *nextPtr;
 
 		nextPtr = bufPtr->nextPtr;
-		RecycleBuffer(chanPtr, bufPtr, 0);
-		chanPtr->inQueueHead = nextPtr;
+		RecycleBuffer(statePtr, bufPtr, 0);
+		statePtr->inQueueHead = nextPtr;
 		if (nextPtr == NULL) {
-		    chanPtr->inQueueTail = nextPtr;
+		    statePtr->inQueueTail = nextPtr;
 		}
 	    }
 	}
 	if (copiedNow < 0) {
-	    if (chanPtr->flags & CHANNEL_EOF) {
+	    if (statePtr->flags & CHANNEL_EOF) {
 		break;
 	    }
-	    if (chanPtr->flags & CHANNEL_BLOCKED) {
-		if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+	    if (statePtr->flags & CHANNEL_BLOCKED) {
+		if (statePtr->flags & CHANNEL_NONBLOCKING) {
 		    break;
 		}
-		chanPtr->flags &= ~CHANNEL_BLOCKED;
+		statePtr->flags &= ~CHANNEL_BLOCKED;
 	    }
 	    result = GetInput(chanPtr);
 	    if (result != 0) {
@@ -4061,7 +4076,7 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
 	    toRead -= copiedNow;
 	}
     }
-    chanPtr->flags &= ~CHANNEL_BLOCKED;
+    statePtr->flags &= ~CHANNEL_BLOCKED;
     if (encoding == NULL) {
 	Tcl_SetByteArrayLength(objPtr, offset);
     } else {
@@ -4104,8 +4119,8 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
  */
 
 static int
-ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
-    Channel *chanPtr;		/* The channel to read. */
+ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
+    ChannelState *statePtr;	/* State of the channel to read. */
     int bytesToRead;		/* Maximum number of characters to store,
 				 * or < 0 to get all available characters.
 				 * Characters are obtained from the first
@@ -4130,7 +4145,7 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
 
     offset = *offsetPtr;
 
-    bufPtr = chanPtr->inQueueHead; 
+    bufPtr = statePtr->inQueueHead; 
     src = bufPtr->buf + bufPtr->nextRemoved;
     srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
 
@@ -4155,8 +4170,8 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
     }
     dst += offset;
 
-    if (chanPtr->flags & INPUT_NEED_NL) {
-	chanPtr->flags &= ~INPUT_NEED_NL;
+    if (statePtr->flags & INPUT_NEED_NL) {
+	statePtr->flags &= ~INPUT_NEED_NL;
 	if ((srcLen == 0) || (*src != '\n')) {
 	    *dst = '\r';
 	    *offsetPtr += 1;
@@ -4170,7 +4185,7 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
 
     srcRead = srcLen;
     dstWrote = toRead;
-    if (TranslateInputEOL(chanPtr, dst, src, &dstWrote, &srcRead) != 0) {
+    if (TranslateInputEOL(statePtr, dst, src, &dstWrote, &srcRead) != 0) {
 	if (dstWrote == 0) {
 	    return -1;
 	}
@@ -4208,8 +4223,8 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
  */
 
 static int
-ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
-    Channel *chanPtr;		/* The channel to read. */
+ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
+    ChannelState *statePtr;	/* State of channel to read. */
     int charsToRead;		/* Maximum number of characters to store,
 				 * or -1 to get all available characters.
 				 * Characters are obtained from the first
@@ -4241,7 +4256,7 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
     factor = *factorPtr;
     offset = *offsetPtr;
 
-    bufPtr = chanPtr->inQueueHead; 
+    bufPtr = statePtr->inQueueHead; 
     src = bufPtr->buf + bufPtr->nextRemoved;
     srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
 
@@ -4286,21 +4301,21 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
     }
     dst = objPtr->bytes + offset;
 
-    oldState = chanPtr->inputEncodingState;
-    if (chanPtr->flags & INPUT_NEED_NL) {
+    oldState = statePtr->inputEncodingState;
+    if (statePtr->flags & INPUT_NEED_NL) {
 	/*
 	 * We want a '\n' because the last character we saw was '\r'.
 	 */
-	 
-	chanPtr->flags &= ~INPUT_NEED_NL;
-	Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
-		chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+
+	statePtr->flags &= ~INPUT_NEED_NL;
+	Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+		statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
 		dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars);
 	if ((dstWrote > 0) && (*dst == '\n')) {
 	    /*
 	     * The next char was a '\n'.  Consume it and produce a '\n'.
 	     */
-	     
+
 	    bufPtr->nextRemoved += srcRead;
 	} else {
 	    /*
@@ -4309,13 +4324,13 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
 
 	    *dst = '\r';
 	}
-	chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+	statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
 	*offsetPtr += 1;
         return 1;
     }
 
-    Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
-	    chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, dst,
+    Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+	    statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst,
 	    dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
     if (srcRead == 0) {
 	/*
@@ -4334,19 +4349,19 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
 	     * file event can be delivered.
 	     */
 
-	    chanPtr->flags |= CHANNEL_NEED_MORE_DATA;
+	    statePtr->flags |= CHANNEL_NEED_MORE_DATA;
 	    return -1;
 	}
 	nextPtr->nextRemoved -= srcLen;
 	memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src,
 		(size_t) srcLen);
-	RecycleBuffer(chanPtr, bufPtr, 0);
-	chanPtr->inQueueHead = nextPtr;
-	return ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr);
+	RecycleBuffer(statePtr, bufPtr, 0);
+	statePtr->inQueueHead = nextPtr;
+	return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
     }
 
     dstRead = dstWrote;
-    if (TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead) != 0) {
+    if (TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead) != 0) {
 	/*
 	 * Hit EOF char.  How many bytes of src correspond to where the
 	 * EOF was located in dst?
@@ -4355,11 +4370,11 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
 	if (dstWrote == 0) {
 	    return -1;
 	}
-	chanPtr->inputEncodingState = oldState;
-	Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
-		chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+	statePtr->inputEncodingState = oldState;
+	Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+		statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
 		dst, dstRead + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
-	TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead);
+	TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
     } 
 
     /*
@@ -4378,15 +4393,15 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
 	char *eof;
 
 	eof = Tcl_UtfAtIndex(dst, toRead);
-	chanPtr->inputEncodingState = oldState;
-	Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
-		chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+	statePtr->inputEncodingState = oldState;
+	Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+		statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
 		dst, eof - dst + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
 	dstRead = dstWrote;
-	TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead);
+	TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
 	numChars -= (dstRead - dstWrote);
     }
-    chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+    statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
 
     bufPtr->nextRemoved += srcRead;
     if (dstWrote > srcRead + 1) {
@@ -4415,8 +4430,8 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
  */
 
 static int
-TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
-    Channel *chanPtr;		/* Channel being read, for EOL translation
+TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
+    ChannelState *statePtr;	/* Channel being read, for EOL translation
 				 * and EOF character. */
     char *dstStart;		/* Output buffer filled with chars by
 				 * applying appropriate EOL translation to
@@ -4436,7 +4451,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
     dstLen = *dstLenPtr;
 
     eof = NULL;
-    inEofChar = chanPtr->inEofChar;
+    inEofChar = statePtr->inEofChar;
     if (inEofChar != '\0') {
 	/*
 	 * Find EOF in translated buffer then compress out the EOL.  The
@@ -4460,7 +4475,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
 	    }
 	}
     }
-    switch (chanPtr->inputTranslation) {
+    switch (statePtr->inputTranslation) {
 	case TCL_TRANSLATE_LF: {
 	    if (dstStart != srcStart) {
 		memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
@@ -4496,7 +4511,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
 		if (*src == '\r') {
 		    src++;
 		    if (src >= srcMax) {
-			chanPtr->flags |= INPUT_NEED_NL;
+			statePtr->flags |= INPUT_NEED_NL;
 		    } else if (*src == '\n') {
 			*dst++ = *src++;
 		    } else {
@@ -4519,17 +4534,17 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
 	    srcEnd = srcStart + dstLen;
 	    srcMax = srcStart + *srcLenPtr;
 
-	    if ((chanPtr->flags & INPUT_SAW_CR) && (src < srcMax)) {
+	    if ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) {
 		if (*src == '\n') {
 		    src++;
 		}
-		chanPtr->flags &= ~INPUT_SAW_CR;
+		statePtr->flags &= ~INPUT_SAW_CR;
 	    }
 	    for ( ; src < srcEnd; ) {
 		if (*src == '\r') {
 		    src++;
 		    if (src >= srcMax) {
-			chanPtr->flags |= INPUT_SAW_CR;
+			statePtr->flags |= INPUT_SAW_CR;
 		    } else if (*src == '\n') {
 			if (srcEnd < srcMax) {
 			    srcEnd++;
@@ -4558,9 +4573,9 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
 	 * EOF character in the output string.
 	 */
 
-	chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
-	chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
-	chanPtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
+	statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+	statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
 	return 1;
     }
 
@@ -4594,21 +4609,29 @@ Tcl_Ungets(chan, str, len, atEnd)
                                  * 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 i, 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 = chanPtr->flags;
-    if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+    flags = statePtr->flags;
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
 	len = -1;
 	goto done;
     }
-    chanPtr->flags = flags;
+    statePtr->flags = flags;
 
     /*
      * If we have encountered a sticky EOF, just punt without storing.
@@ -4618,10 +4641,10 @@ Tcl_Ungets(chan, str, len, atEnd)
      * in each operation.
      */
 
-    if (chanPtr->flags & CHANNEL_STICKY_EOF) {
+    if (statePtr->flags & CHANNEL_STICKY_EOF) {
 	goto done;
     }
-    chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
+    statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
 
     bufPtr = AllocChannelBuffer(len);
     for (i = 0; i < len; i++) {
@@ -4629,17 +4652,17 @@ Tcl_Ungets(chan, str, len, atEnd)
     }
     bufPtr->nextAdded += len;
 
-    if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+    if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
         bufPtr->nextPtr = (ChannelBuffer *) NULL;
-        chanPtr->inQueueHead = bufPtr;
-        chanPtr->inQueueTail = bufPtr;
+        statePtr->inQueueHead = bufPtr;
+        statePtr->inQueueTail = bufPtr;
     } else if (atEnd) {
         bufPtr->nextPtr = (ChannelBuffer *) NULL;
-        chanPtr->inQueueTail->nextPtr = bufPtr;
-        chanPtr->inQueueTail = bufPtr;
+        statePtr->inQueueTail->nextPtr = bufPtr;
+        statePtr->inQueueTail = bufPtr;
     } else {
-        bufPtr->nextPtr = chanPtr->inQueueHead;
-        chanPtr->inQueueHead = bufPtr;
+        bufPtr->nextPtr = statePtr->inQueueHead;
+        statePtr->inQueueHead = bufPtr;
     }
 
     done:
@@ -4673,10 +4696,16 @@ Tcl_Flush(chan)
     Tcl_Channel chan;			/* The Channel to flush. */
 {
     int result;				/* Of calling FlushChannel. */
-    Channel *chanPtr;			/* The actual channel. */
+    Channel *chanPtr  = (Channel *) chan;	/* The actual channel. */
+    ChannelState *statePtr = chanPtr->state;	/* State of actual channel. */
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return -1;
     }
 
@@ -4684,14 +4713,14 @@ Tcl_Flush(chan)
      * Force current output buffer to be output also.
      */
 
-    if ((chanPtr->curOutPtr != NULL)
-	    && (chanPtr->curOutPtr->nextAdded > 0)) {
-	chanPtr->flags |= BUFFER_READY;
+    if ((statePtr->curOutPtr != NULL)
+	    && (statePtr->curOutPtr->nextAdded > 0)) {
+        statePtr->flags |= BUFFER_READY;
     }
-
+    
     result = FlushChannel(NULL, chanPtr, 0);
     if (result != 0) {
-	return TCL_ERROR;
+        return TCL_ERROR;
     }
 
     return TCL_OK;
@@ -4716,32 +4745,32 @@ Tcl_Flush(chan)
  */
 
 static void
-DiscardInputQueued(chanPtr, discardSavedBuffers)
-    Channel *chanPtr;		/* Channel on which to discard
-				 * the queued input. */
+DiscardInputQueued(statePtr, discardSavedBuffers)
+    ChannelState *statePtr;	/* Channel on which to discard
+                                 * the queued input. */
     int discardSavedBuffers;	/* If non-zero, discard all buffers including
-				 * last one. */
+                                 * last one. */
 {
     ChannelBuffer *bufPtr, *nxtPtr;	/* Loop variables. */
 
-    bufPtr = chanPtr->inQueueHead;
-    chanPtr->inQueueHead = (ChannelBuffer *) NULL;
-    chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+    bufPtr = statePtr->inQueueHead;
+    statePtr->inQueueHead = (ChannelBuffer *) NULL;
+    statePtr->inQueueTail = (ChannelBuffer *) NULL;
     for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
-	nxtPtr = bufPtr->nextPtr;
-	RecycleBuffer(chanPtr, bufPtr, discardSavedBuffers);
+        nxtPtr = bufPtr->nextPtr;
+        RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
     }
 
     /*
      * If discardSavedBuffers is nonzero, must also discard any previously
      * saved buffer in the saveInBufPtr field.
      */
-
+    
     if (discardSavedBuffers) {
-	if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
-	    ckfree((char *) chanPtr->saveInBufPtr);
-	    chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
-	}
+        if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) {
+            ckfree((char *) statePtr->saveInBufPtr);
+            statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
+        }
     }
 }
 
@@ -4770,6 +4799,7 @@ GetInput(chanPtr)
     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 */
 
     /*
      * Prevent reading from a dead channel -- a channel that has been closed
@@ -4778,34 +4808,62 @@ GetInput(chanPtr)
      * interpreter.
      */
     
-    if (CheckForDeadChannel(NULL, chanPtr)) {
+    if (CheckForDeadChannel(NULL, statePtr)) {
 	return EINVAL;
     }
 
     /*
+     * 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.
+     *
+     * Two possibilities for the state: No buffers in it, or a single
+     * empty buffer. In the latter case we can recycle it now.
+     */
+
+    if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
+        if (statePtr->inQueueHead != (ChannelBuffer*) NULL) {
+	    RecycleBuffer(statePtr, statePtr->inQueueHead, 0);
+	    statePtr->inQueueHead = (ChannelBuffer*) NULL;
+	}
+
+	statePtr->inQueueHead = chanPtr->inQueueHead;
+	statePtr->inQueueTail = chanPtr->inQueueTail;
+	chanPtr->inQueueHead  = (ChannelBuffer*) NULL;
+	chanPtr->inQueueTail  = (ChannelBuffer*) 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 = chanPtr->inQueueTail;
+    bufPtr = statePtr->inQueueTail;
     if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) {
         toRead = bufPtr->bufLength - bufPtr->nextAdded;
     } else {
-	bufPtr = chanPtr->saveInBufPtr;
-	chanPtr->saveInBufPtr = NULL;
+	bufPtr = statePtr->saveInBufPtr;
+	statePtr->saveInBufPtr = NULL;
 	if (bufPtr == NULL) {
-	    bufPtr = AllocChannelBuffer(chanPtr->bufSize);
+	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
 	}
         bufPtr->nextPtr = (ChannelBuffer *) NULL;
 
-        toRead = chanPtr->bufSize;
-        if (chanPtr->inQueueTail == NULL) {
-            chanPtr->inQueueHead = bufPtr;
+        toRead = statePtr->bufSize;
+        if (statePtr->inQueueTail == NULL) {
+            statePtr->inQueueHead = bufPtr;
         } else {
-            chanPtr->inQueueTail->nextPtr = bufPtr;
+            statePtr->inQueueTail->nextPtr = bufPtr;
         }
-        chanPtr->inQueueTail = bufPtr;
+        statePtr->inQueueTail = bufPtr;
     }
       
     /*
@@ -4813,11 +4871,11 @@ GetInput(chanPtr)
      * platforms it is impossible to read from a device after EOF.
      */
 
-    if (chanPtr->flags & CHANNEL_EOF) {
+    if (statePtr->flags & CHANNEL_EOF) {
 	return 0;
     }
 
-    nread = (*chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+    nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
 	    bufPtr->buf + bufPtr->nextAdded, toRead, &result);
 
     if (nread > 0) {
@@ -4831,14 +4889,14 @@ GetInput(chanPtr)
 	 */
             
 	if (nread < toRead) {
-	    chanPtr->flags |= CHANNEL_BLOCKED;
+	    statePtr->flags |= CHANNEL_BLOCKED;
 	}
     } else if (nread == 0) {
-	chanPtr->flags |= CHANNEL_EOF;
-	chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+	statePtr->flags |= CHANNEL_EOF;
+	statePtr->inputEncodingFlags |= TCL_ENCODING_END;
     } else if (nread < 0) {
 	if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
-	    chanPtr->flags |= CHANNEL_BLOCKED;
+	    statePtr->flags |= CHANNEL_BLOCKED;
 	    result = EAGAIN;
 	}
 	Tcl_SetErrno(result);
@@ -4871,7 +4929,8 @@ Tcl_Seek(chan, offset, mode)
     int offset;			/* Offset to seek to. */
     int mode;			/* Relative to which location to seek? */
 {
-    Channel *chanPtr;		/* The real IO channel. */
+    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
     int inputBuffered, outputBuffered;
     int result;			/* Of device driver operations. */
@@ -4880,8 +4939,7 @@ Tcl_Seek(chan, offset, mode)
                                  * seek operation? If so, must restore to
                                  * nonblocking mode after the seek. */
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
 	return -1;
     }
 
@@ -4892,7 +4950,13 @@ Tcl_Seek(chan, offset, mode)
      * registered in an interpreter.
      */
 
-    if (CheckForDeadChannel(NULL,chanPtr)) return -1;
+    if (CheckForDeadChannel(NULL, statePtr)) return -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
@@ -4909,21 +4973,32 @@ Tcl_Seek(chan, offset, mode)
      * output is buffered, cannot compute the current position.
      */
 
-    for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
-             bufPtr != (ChannelBuffer *) NULL;
-             bufPtr = bufPtr->nextPtr) {
+    for (bufPtr = statePtr->inQueueHead, inputBuffered = 0;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
         inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
     }
-    for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
-             bufPtr != (ChannelBuffer *) NULL;
-             bufPtr = bufPtr->nextPtr) {
+
+    /*
+     * Don't forget the bytes in the topmost pushback area.
+     */
+
+    for (bufPtr = statePtr->topChanPtr->inQueueHead;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
+        inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+    }
+
+    for (bufPtr = statePtr->outQueueHead, outputBuffered = 0;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
         outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
     }
-    if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
-           (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
-        chanPtr->flags |= BUFFER_READY;
+    if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+	    (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+        statePtr->flags |= BUFFER_READY;
         outputBuffered +=
-            (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
+            (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
     }
 
     if ((inputBuffered != 0) && (outputBuffered != 0)) {
@@ -4945,14 +5020,14 @@ Tcl_Seek(chan, offset, mode)
      * the seek.
      */
 
-    DiscardInputQueued(chanPtr, 0);
+    DiscardInputQueued(statePtr, 0);
 
     /*
      * Reset EOF and BLOCKED flags. We invalidate them by moving the
      * access point. Also clear CR related flags.
      */
 
-    chanPtr->flags &=
+    statePtr->flags &=
         (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR));
     
     /*
@@ -4963,20 +5038,15 @@ Tcl_Seek(chan, offset, mode)
      */
 
     wasAsync = 0;
-    if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+    if (statePtr->flags & CHANNEL_NONBLOCKING) {
         wasAsync = 1;
-        result = 0;
-        if (chanPtr->typePtr->blockModeProc != NULL) {
-            result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
-                    TCL_MODE_BLOCKING);
-        }
-        if (result != 0) {
-            Tcl_SetErrno(result);
-            return -1;
-        }
-        chanPtr->flags &= (~(CHANNEL_NONBLOCKING));
-        if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
-            chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
+        result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
+	if (result != 0) {
+	    return -1;
+	}
+        statePtr->flags &= (~(CHANNEL_NONBLOCKING));
+        if (statePtr->flags & BG_FLUSH_SCHEDULED) {
+            statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
         }
     }
     
@@ -5012,16 +5082,11 @@ Tcl_Seek(chan, offset, mode)
      */
     
     if (wasAsync) {
-        chanPtr->flags |= CHANNEL_NONBLOCKING;
-        result = 0;
-        if (chanPtr->typePtr->blockModeProc != NULL) {
-            result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
-                    TCL_MODE_NONBLOCKING);
-        }
-        if (result != 0) {
-            Tcl_SetErrno(result);
-            return -1;
-        }
+        statePtr->flags |= CHANNEL_NONBLOCKING;
+        result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
+	if (result != 0) {
+	    return -1;
+	}
     }
 
     return curPos;
@@ -5050,14 +5115,14 @@ int
 Tcl_Tell(chan)
     Tcl_Channel chan;			/* The channel to return pos for. */
 {
-    Channel *chanPtr;			/* The actual channel to tell on. */
+    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *bufPtr;
     int inputBuffered, outputBuffered;
     int result;				/* Of calling device driver. */
     int curPos;				/* Position on device. */
 
-    chanPtr = (Channel *) chan;
-    if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
 	return -1;
     }
 
@@ -5068,11 +5133,17 @@ Tcl_Tell(chan)
      * registered in an interpreter.
      */
 
-    if (CheckForDeadChannel(NULL,chanPtr)) {
+    if (CheckForDeadChannel(NULL, statePtr)) {
 	return -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.
      */
@@ -5087,21 +5158,21 @@ Tcl_Tell(chan)
      * output is buffered, cannot compute the current position.
      */
 
-    for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
-             bufPtr != (ChannelBuffer *) NULL;
-             bufPtr = bufPtr->nextPtr) {
+    for (bufPtr = statePtr->inQueueHead, inputBuffered = 0;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
         inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
     }
-    for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
-             bufPtr != (ChannelBuffer *) NULL;
-             bufPtr = bufPtr->nextPtr) {
+    for (bufPtr = statePtr->outQueueHead, outputBuffered = 0;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
         outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
     }
-    if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
-           (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
-        chanPtr->flags |= BUFFER_READY;
+    if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+	    (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+        statePtr->flags |= BUFFER_READY;
         outputBuffered +=
-            (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
+            (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
     }
 
     if ((inputBuffered != 0) && (outputBuffered != 0)) {
@@ -5145,18 +5216,33 @@ Tcl_Tell(chan)
  */
  
 static int
-CheckChannelErrors(chanPtr, direction)
-    Channel *chanPtr;	    /* Channel to check. */
-    int direction;	    /* Test if channel supports desired operation:
-			     * TCL_READABLE, TCL_WRITABLE. */
+CheckChannelErrors(statePtr, flags)
+    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 (chanPtr->unreportedError != 0) {
-        Tcl_SetErrno(chanPtr->unreportedError);
-        chanPtr->unreportedError = 0;
+    if (statePtr->unreportedError != 0) {
+        Tcl_SetErrno(statePtr->unreportedError);
+        statePtr->unreportedError = 0;
+        return -1;
+    }
+
+    /*
+     * Only the raw read and write operations are allowed during close
+     * in order to drain data from stacked channels.
+     */
+
+    if ((statePtr->flags & CHANNEL_CLOSED) &&
+	    ((flags & CHANNEL_RAW_MODE) == 0)) {
+        Tcl_SetErrno(EACCES);
         return -1;
     }
 
@@ -5164,16 +5250,20 @@ CheckChannelErrors(chanPtr, direction)
      * Fail if the channel is not opened for desired operation.
      */
 
-    if ((chanPtr->flags & direction) == 0) {
+    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 (chanPtr->csPtr != NULL) {
+    if ((statePtr->csPtr != NULL) && ((flags & CHANNEL_RAW_MODE) == 0)) {
 	Tcl_SetErrno(EBUSY);
 	return -1;
     }
@@ -5186,10 +5276,10 @@ CheckChannelErrors(chanPtr, direction)
 	 * We want to discover these conditions anew in each operation.
 	 */
 	
-	if ((chanPtr->flags & CHANNEL_STICKY_EOF) == 0) {
-	    chanPtr->flags &= ~CHANNEL_EOF;
+	if ((statePtr->flags & CHANNEL_STICKY_EOF) == 0) {
+	    statePtr->flags &= ~CHANNEL_EOF;
 	}
-	chanPtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+	statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
     }
 
     return 0;
@@ -5215,12 +5305,12 @@ int
 Tcl_Eof(chan)
     Tcl_Channel chan;			/* Does this channel have EOF? */
 {
-    Channel *chanPtr;		/* The real channel structure. */
+    ChannelState *statePtr = ((Channel *) chan)->state;
+					/* State of real channel structure. */
 
-    chanPtr = (Channel *) chan;
-    return ((chanPtr->flags & CHANNEL_STICKY_EOF) ||
-            ((chanPtr->flags & CHANNEL_EOF) && (Tcl_InputBuffered(chan) == 0)))
-        ? 1 : 0;
+    return ((statePtr->flags & CHANNEL_STICKY_EOF) ||
+            ((statePtr->flags & CHANNEL_EOF) &&
+		    (Tcl_InputBuffered(chan) == 0))) ? 1 : 0;
 }
 
 /*
@@ -5243,10 +5333,10 @@ int
 Tcl_InputBlocked(chan)
     Tcl_Channel chan;			/* Is this channel blocked? */
 {
-    Channel *chanPtr;		/* The real channel structure. */
+    ChannelState *statePtr = ((Channel *) chan)->state;
+					/* State of real channel structure. */
 
-    chanPtr = (Channel *) chan;
-    return (chanPtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
+    return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
 }
 
 /*
@@ -5255,7 +5345,7 @@ Tcl_InputBlocked(chan)
  * Tcl_InputBuffered --
  *
  *	Returns the number of bytes of input currently buffered in the
- *	internal buffer of a channel.
+ *	common internal buffer of a channel.
  *
  * Results:
  *	The number of input bytes buffered, or zero if the channel is not
@@ -5271,16 +5361,63 @@ int
 Tcl_InputBuffered(chan)
     Tcl_Channel chan;			/* The channel to query. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr = ((Channel *) chan)->state;
+					/* State of real channel structure. */
+    ChannelBuffer *bufPtr;
     int bytesBuffered;
+
+    for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
+        bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+    }
+
+    /*
+     * Don't forget the bytes in the topmost pushback area.
+     */
+
+    for (bufPtr = statePtr->topChanPtr->inQueueHead;
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
+        bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+    }
+
+    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(chan)
+    Tcl_Channel chan;			/* The channel to query. */
+{
+    Channel *chanPtr = (Channel *) chan;
+					/* real channel structure. */
     ChannelBuffer *bufPtr;
+    int bytesBuffered;
 
-    chanPtr = (Channel *) chan;
     for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
-             bufPtr != (ChannelBuffer *) NULL;
-             bufPtr = bufPtr->nextPtr) {
+	 bufPtr != (ChannelBuffer *) NULL;
+	 bufPtr = bufPtr->nextPtr) {
         bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
     }
+
     return bytesBuffered;
 }
 
@@ -5307,7 +5444,7 @@ Tcl_SetChannelBufferSize(chan, sz)
                                          * to set. */
     int sz;				/* The size to set. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr;		/* State of real channel structure. */
     
     /*
      * If the buffer size is smaller than 10 bytes or larger than one MByte,
@@ -5321,16 +5458,16 @@ Tcl_SetChannelBufferSize(chan, sz)
         return;
     }
 
-    chanPtr = (Channel *) chan;
-    chanPtr->bufSize = sz;
+    statePtr = ((Channel *) chan)->state;
+    statePtr->bufSize = sz;
 
-    if (chanPtr->outputStage != NULL) {
-	ckfree((char *) chanPtr->outputStage);
-	chanPtr->outputStage = NULL;
+    if (statePtr->outputStage != NULL) {
+	ckfree((char *) statePtr->outputStage);
+	statePtr->outputStage = NULL;
     }
-    if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
-	chanPtr->outputStage = (char *)
-		ckalloc((unsigned) (chanPtr->bufSize + 2));
+    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+	statePtr->outputStage = (char *)
+	    ckalloc((unsigned) (statePtr->bufSize + 2));
     }
 }
 
@@ -5355,10 +5492,10 @@ Tcl_GetChannelBufferSize(chan)
     Tcl_Channel chan;		/* The channel for which to find the
                                  * buffer size. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr = ((Channel *) chan)->state;
+					/* State of real channel structure. */
 
-    chanPtr = (Channel *) chan;
-    return chanPtr->bufSize;
+    return statePtr->bufSize;
 }
 
 /*
@@ -5401,7 +5538,7 @@ Tcl_BadChannelOption(interp, optionName, optionList)
 {
     if (interp) {
 	CONST char *genericopt = 
-	    	"blocking buffering buffersize encoding eofchar translation";
+	    "blocking buffering buffersize encoding eofchar translation";
 	char **argv;
 	int  argc, i;
 	Tcl_DString ds;
@@ -5413,12 +5550,12 @@ Tcl_BadChannelOption(interp, optionName, optionList)
 	    Tcl_DStringAppend(&ds, optionList, -1);
 	}
 	if (Tcl_SplitList(interp, Tcl_DStringValue(&ds), 
-	      	  &argc, &argv) != TCL_OK) {
+		&argc, &argv) != TCL_OK) {
 	    panic("malformed option list in channel driver");
 	}
 	Tcl_ResetResult(interp);
 	Tcl_AppendResult(interp, "bad option \"", optionName, 
-		 "\": should be one of ", (char *) NULL);
+		"\": should be one of ", (char *) NULL);
 	argc--;
 	for (i = 0; i < argc; i++) {
 	    Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
@@ -5461,30 +5598,39 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
     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;
 
     /*
-     * If we are in the middle of a background copy, use the saved 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 (chanPtr->csPtr) {
-	if (chanPtr == chanPtr->csPtr->readPtr) {
-	    flags = chanPtr->csPtr->readFlags;
-	} else {
-	    flags = chanPtr->csPtr->writeFlags;
-	}
-    } else {
-	flags = chanPtr->flags;
+    if (CheckForDeadChannel(interp, statePtr)) {
+	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.
+     * This operation should occur at the top of a channel stack.
      */
 
-    if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR;
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * If we are in the middle of a background copy, use the saved flags.
+     */
+
+    if (statePtr->csPtr) {
+	if (chanPtr == statePtr->csPtr->readPtr) {
+	    flags = statePtr->csPtr->readFlags;
+	} else {
+	    flags = statePtr->csPtr->writeFlags;
+	}
+    } else {
+	flags = statePtr->flags;
+    }
 
     /*
      * If the optionName is NULL it means that we want a list of all
@@ -5529,7 +5675,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
         if (len == 0) {
             Tcl_DStringAppendElement(dsPtr, "-buffersize");
         }
-        TclFormatInt(optionVal, chanPtr->bufSize);
+        TclFormatInt(optionVal, statePtr->bufSize);
         Tcl_DStringAppendElement(dsPtr, optionVal);
         if (len > 0) {
             return TCL_OK;
@@ -5541,11 +5687,11 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
 	if (len == 0) {
 	    Tcl_DStringAppendElement(dsPtr, "-encoding");
 	}
-	if (chanPtr->encoding == NULL) {
+	if (statePtr->encoding == NULL) {
 	    Tcl_DStringAppendElement(dsPtr, "binary");
 	} else {
 	    Tcl_DStringAppendElement(dsPtr,
-		    Tcl_GetEncodingName(chanPtr->encoding));
+		    Tcl_GetEncodingName(statePtr->encoding));
 	}
 	if (len > 0) {
 	    return TCL_OK;
@@ -5562,22 +5708,22 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
             Tcl_DStringStartSublist(dsPtr);
         }
         if (flags & TCL_READABLE) {
-            if (chanPtr->inEofChar == 0) {
+            if (statePtr->inEofChar == 0) {
                 Tcl_DStringAppendElement(dsPtr, "");
             } else {
                 char buf[4];
 
-                sprintf(buf, "%c", chanPtr->inEofChar);
+                sprintf(buf, "%c", statePtr->inEofChar);
                 Tcl_DStringAppendElement(dsPtr, buf);
             }
         }
         if (flags & TCL_WRITABLE) {
-            if (chanPtr->outEofChar == 0) {
+            if (statePtr->outEofChar == 0) {
                 Tcl_DStringAppendElement(dsPtr, "");
             } else {
                 char buf[4];
 
-                sprintf(buf, "%c", chanPtr->outEofChar);
+                sprintf(buf, "%c", statePtr->outEofChar);
                 Tcl_DStringAppendElement(dsPtr, buf);
             }
         }
@@ -5600,22 +5746,22 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
             Tcl_DStringStartSublist(dsPtr);
         }
         if (flags & TCL_READABLE) {
-            if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
+            if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
                 Tcl_DStringAppendElement(dsPtr, "auto");
-            } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
+            } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
                 Tcl_DStringAppendElement(dsPtr, "cr");
-            } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
+            } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
                 Tcl_DStringAppendElement(dsPtr, "crlf");
             } else {
                 Tcl_DStringAppendElement(dsPtr, "lf");
             }
         }
         if (flags & TCL_WRITABLE) {
-            if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
+            if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
                 Tcl_DStringAppendElement(dsPtr, "auto");
-            } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
+            } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
                 Tcl_DStringAppendElement(dsPtr, "cr");
-            } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
+            } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
                 Tcl_DStringAppendElement(dsPtr, "crlf");
             } else {
                 Tcl_DStringAppendElement(dsPtr, "lf");
@@ -5636,7 +5782,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
 	 */
 
         return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
-		  interp, optionName, dsPtr);
+		interp, optionName, dsPtr);
     } else {
 	/*
 	 * no driver specific options case.
@@ -5674,27 +5820,25 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
     char *newValue;		/* New value for option. */
 {
     int newMode;		/* New (numeric) mode to sert. */
-    Channel *chanPtr;		/* The real IO channel. */
+    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     size_t len;			/* Length of optionName string. */
     int argc;
     char **argv;
-    
-    chanPtr = (Channel *) chan;
 
     /*
      * If the channel is in the middle of a background copy, fail.
      */
 
-    if (chanPtr->csPtr) {
+    if (statePtr->csPtr) {
 	if (interp) {
 	    Tcl_AppendResult(interp,
-	         "unable to set channel options: background copy in progress",
-		 (char *) NULL);
+		    "unable to set channel options: background copy in progress",
+		    (char *) NULL);
 	}
         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
@@ -5702,8 +5846,16 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
      * registered in an interpreter.
      */
 
-    if (CheckForDeadChannel(NULL,chanPtr)) return TCL_ERROR;
-    
+    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 ((len > 2) && (optionName[1] == 'b') &&
@@ -5721,16 +5873,16 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
             (strncmp(optionName, "-buffering", len) == 0)) {
         len = strlen(newValue);
         if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
-            chanPtr->flags &=
+            statePtr->flags &=
                 (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
         } else if ((newValue[0] == 'l') &&
                 (strncmp(newValue, "line", len) == 0)) {
-            chanPtr->flags &= (~(CHANNEL_UNBUFFERED));
-            chanPtr->flags |= CHANNEL_LINEBUFFERED;
+            statePtr->flags &= (~(CHANNEL_UNBUFFERED));
+            statePtr->flags |= CHANNEL_LINEBUFFERED;
         } else if ((newValue[0] == 'n') &&
                 (strncmp(newValue, "none", len) == 0)) {
-            chanPtr->flags &= (~(CHANNEL_LINEBUFFERED));
-            chanPtr->flags |= CHANNEL_UNBUFFERED;
+            statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
+            statePtr->flags |= CHANNEL_UNBUFFERED;
         } else {
             if (interp) {
                 Tcl_AppendResult(interp, "bad value for -buffering: ",
@@ -5742,9 +5894,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
 	return TCL_OK;
     } else if ((len > 7) && (optionName[1] == 'b') &&
             (strncmp(optionName, "-buffersize", len) == 0)) {
-        chanPtr->bufSize = atoi(newValue);	/* INTL: "C", UTF safe. */
-        if ((chanPtr->bufSize < 10) || (chanPtr->bufSize > (1024 * 1024))) {
-            chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
+        statePtr->bufSize = atoi(newValue);	/* INTL: "C", UTF safe. */
+        if ((statePtr->bufSize < 10) || (statePtr->bufSize > (1024 * 1024))) {
+            statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
         }
     } else if ((len > 2) && (optionName[1] == 'e') &&
 	    (strncmp(optionName, "-encoding", len) == 0)) {
@@ -5758,13 +5910,13 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
 		return TCL_ERROR;
 	    }
 	}
-	Tcl_FreeEncoding(chanPtr->encoding);
-	chanPtr->encoding = encoding;
-	chanPtr->inputEncodingState = NULL;
-	chanPtr->inputEncodingFlags = TCL_ENCODING_START;
-	chanPtr->outputEncodingState = NULL;
-	chanPtr->outputEncodingFlags = TCL_ENCODING_START;
-	chanPtr->flags &= ~CHANNEL_NEED_MORE_DATA;
+	Tcl_FreeEncoding(statePtr->encoding);
+	statePtr->encoding = encoding;
+	statePtr->inputEncodingState = NULL;
+	statePtr->inputEncodingFlags = TCL_ENCODING_START;
+	statePtr->outputEncodingState = NULL;
+	statePtr->outputEncodingFlags = TCL_ENCODING_START;
+	statePtr->flags &= ~CHANNEL_NEED_MORE_DATA;
 	UpdateInterest(chanPtr);
     } else if ((len > 2) && (optionName[1] == 'e') &&
             (strncmp(optionName, "-eofchar", len) == 0)) {
@@ -5772,14 +5924,14 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
             return TCL_ERROR;
         }
         if (argc == 0) {
-            chanPtr->inEofChar = 0;
-            chanPtr->outEofChar = 0;
+            statePtr->inEofChar = 0;
+            statePtr->outEofChar = 0;
         } else if (argc == 1) {
-            if (chanPtr->flags & TCL_WRITABLE) {
-                chanPtr->outEofChar = (int) argv[0][0];
+            if (statePtr->flags & TCL_WRITABLE) {
+                statePtr->outEofChar = (int) argv[0][0];
             }
-            if (chanPtr->flags & TCL_READABLE) {
-                chanPtr->inEofChar = (int) argv[0][0];
+            if (statePtr->flags & TCL_READABLE) {
+                statePtr->inEofChar = (int) argv[0][0];
             }
         } else if (argc != 2) {
             if (interp) {
@@ -5790,11 +5942,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
             ckfree((char *) argv);
             return TCL_ERROR;
         } else {
-            if (chanPtr->flags & TCL_READABLE) {
-                chanPtr->inEofChar = (int) argv[0][0];
+            if (statePtr->flags & TCL_READABLE) {
+                statePtr->inEofChar = (int) argv[0][0];
             }
-            if (chanPtr->flags & TCL_WRITABLE) {
-                chanPtr->outEofChar = (int) argv[1][0];
+            if (statePtr->flags & TCL_WRITABLE) {
+                statePtr->outEofChar = (int) argv[1][0];
             }
         }
         if (argv != (char **) NULL) {
@@ -5810,11 +5962,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
         }
 
         if (argc == 1) {
-	    readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
-	    writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
+	    readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
+	    writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
 	} else if (argc == 2) {
-	    readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
-	    writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
+	    readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
+	    writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
 	} else {
             if (interp) {
                 Tcl_AppendResult(interp,
@@ -5827,14 +5979,14 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
 
 	if (readMode) {
 	    if (*readMode == '\0') {
-		newMode = chanPtr->inputTranslation;
+		newMode = statePtr->inputTranslation;
 	    } else if (strcmp(readMode, "auto") == 0) {
 		newMode = TCL_TRANSLATE_AUTO;
 	    } else if (strcmp(readMode, "binary") == 0) {
 		newMode = TCL_TRANSLATE_LF;
-		chanPtr->inEofChar = 0;
-		Tcl_FreeEncoding(chanPtr->encoding);		    
-		chanPtr->encoding = NULL;
+		statePtr->inEofChar = 0;
+		Tcl_FreeEncoding(statePtr->encoding);		    
+		statePtr->encoding = NULL;
 	    } else if (strcmp(readMode, "lf") == 0) {
 		newMode = TCL_TRANSLATE_LF;
 	    } else if (strcmp(readMode, "cr") == 0) {
@@ -5860,10 +6012,10 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
 	     * complete the line.
 	     */
 
-	    if (newMode != chanPtr->inputTranslation) {
-		chanPtr->inputTranslation = (Tcl_EolTranslation) newMode;
-		chanPtr->flags &= ~(INPUT_SAW_CR);
-		chanPtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
+	    if (newMode != statePtr->inputTranslation) {
+		statePtr->inputTranslation = (Tcl_EolTranslation) newMode;
+		statePtr->flags &= ~(INPUT_SAW_CR);
+		statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
 		UpdateInterest(chanPtr);
 	    }
 	}
@@ -5878,24 +6030,24 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
 		 * coded later.
 		 */
 
-		if (strcmp(chanPtr->typePtr->typeName, "tcp") == 0) {
-		    chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
+		if (strcmp(Tcl_ChannelName(chanPtr->typePtr), "tcp") == 0) {
+		    statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
 		} else {
-		    chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+		    statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
 		}
 	    } else if (strcmp(writeMode, "binary") == 0) {
-		chanPtr->outEofChar = 0;
-		chanPtr->outputTranslation = TCL_TRANSLATE_LF;
-		Tcl_FreeEncoding(chanPtr->encoding);		    
-		chanPtr->encoding = NULL;
+		statePtr->outEofChar = 0;
+		statePtr->outputTranslation = TCL_TRANSLATE_LF;
+		Tcl_FreeEncoding(statePtr->encoding);		    
+		statePtr->encoding = NULL;
 	    } else if (strcmp(writeMode, "lf") == 0) {
-		chanPtr->outputTranslation = TCL_TRANSLATE_LF;
+		statePtr->outputTranslation = TCL_TRANSLATE_LF;
 	    } else if (strcmp(writeMode, "cr") == 0) {
-		chanPtr->outputTranslation = TCL_TRANSLATE_CR;
+		statePtr->outputTranslation = TCL_TRANSLATE_CR;
 	    } else if (strcmp(writeMode, "crlf") == 0) {
-		chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
+		statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
 	    } else if (strcmp(writeMode, "platform") == 0) {
-		chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+		statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
 	    } else {
 		if (interp) {
 		    Tcl_AppendResult(interp,
@@ -5920,17 +6072,17 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
      * If bufsize changes, need to get rid of old utility buffer.
      */
 
-    if (chanPtr->saveInBufPtr != NULL) {
-	RecycleBuffer(chanPtr, chanPtr->saveInBufPtr, 1);
-	chanPtr->saveInBufPtr = NULL;
+    if (statePtr->saveInBufPtr != NULL) {
+	RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
+	statePtr->saveInBufPtr = NULL;
     }
-    if (chanPtr->inQueueHead != NULL) {
-	if ((chanPtr->inQueueHead->nextPtr == NULL)
-		&& (chanPtr->inQueueHead->nextAdded ==
-			chanPtr->inQueueHead->nextRemoved)) {
-	    RecycleBuffer(chanPtr, chanPtr->inQueueHead, 1);
-	    chanPtr->inQueueHead = NULL;
-	    chanPtr->inQueueTail = NULL;
+    if (statePtr->inQueueHead != NULL) {
+	if ((statePtr->inQueueHead->nextPtr == NULL)
+		&& (statePtr->inQueueHead->nextAdded ==
+			statePtr->inQueueHead->nextRemoved)) {
+	    RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+	    statePtr->inQueueHead = NULL;
+	    statePtr->inQueueTail = NULL;
 	}
     }
 
@@ -5938,13 +6090,13 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
      * If encoding or bufsize changes, need to update output staging buffer.
      */
 
-    if (chanPtr->outputStage != NULL) {
-	ckfree((char *) chanPtr->outputStage);
-	chanPtr->outputStage = NULL;
+    if (statePtr->outputStage != NULL) {
+	ckfree((char *) statePtr->outputStage);
+	statePtr->outputStage = NULL;
     }
-    if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
-	chanPtr->outputStage = (char *) 
-		ckalloc((unsigned) (chanPtr->bufSize + 2));
+    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+	statePtr->outputStage = (char *) 
+	    ckalloc((unsigned) (statePtr->bufSize + 2));
     }
     return TCL_OK;
 }
@@ -5974,6 +6126,7 @@ CleanupChannelHandlers(interp, chanPtr)
     Tcl_Interp *interp;
     Channel *chanPtr;
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     EventScriptRecord *sPtr, *prevPtr, *nextPtr;
 
     /*
@@ -5981,26 +6134,26 @@ CleanupChannelHandlers(interp, chanPtr)
      * given interpreter.
      */
     
-    for (sPtr = chanPtr->scriptRecordPtr,
-	     prevPtr = (EventScriptRecord *) NULL;
-	     sPtr != (EventScriptRecord *) NULL;
-	     sPtr = nextPtr) {
-	nextPtr = sPtr->nextPtr;
-	if (sPtr->interp == interp) {
-	    if (prevPtr == (EventScriptRecord *) NULL) {
-		chanPtr->scriptRecordPtr = nextPtr;
-	    } else {
-		prevPtr->nextPtr = nextPtr;
-	    }
+    for (sPtr = statePtr->scriptRecordPtr,
+             prevPtr = (EventScriptRecord *) NULL;
+	 sPtr != (EventScriptRecord *) NULL;
+	 sPtr = nextPtr) {
+        nextPtr = sPtr->nextPtr;
+        if (sPtr->interp == interp) {
+            if (prevPtr == (EventScriptRecord *) NULL) {
+                statePtr->scriptRecordPtr = nextPtr;
+            } else {
+                prevPtr->nextPtr = nextPtr;
+            }
 
-	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
-		    TclChannelEventScriptInvoker, (ClientData) sPtr);
+            Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+                    TclChannelEventScriptInvoker, (ClientData) sPtr);
 
 	    Tcl_DecrRefCount(sPtr->scriptPtr);
-	    ckfree((char *) sPtr);
-	} else {
-	    prevPtr = sPtr;
-	}
+            ckfree((char *) sPtr);
+        } else {
+            prevPtr = sPtr;
+        }
     }
 }
 
@@ -6010,7 +6163,7 @@ CleanupChannelHandlers(interp, chanPtr)
  * Tcl_NotifyChannel --
  *
  *	This procedure is called by a channel driver when a driver
- *	detects an event on a channel.	This procedure is responsible
+ *	detects an event on a channel.  This procedure is responsible
  *	for actually handling the event by invoking any channel
  *	handler callbacks.
  *
@@ -6031,28 +6184,138 @@ Tcl_NotifyChannel(channel, mask)
 				 * 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;
+#ifdef TCL_CHANNEL_VERSION_2
+    Channel* upChanPtr;
+    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 != ((Channel*) NULL))) {
+        upChanPtr = chanPtr->upChanPtr;
+	upTypePtr = upChanPtr->typePtr;
+
+	if ((Tcl_ChannelVersion(upTypePtr) == TCL_CHANNEL_VERSION_2) &&
+		(Tcl_ChannelHandlerProc(upTypePtr) !=
+			((Tcl_DriverHandlerProc *) NULL))) {
+
+	    Tcl_DriverHandlerProc* handlerProc =
+		Tcl_ChannelHandlerProc(upTypePtr);
+
+	  mask = (*handlerProc) (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.
+     */
+     
+    Tcl_Preserve((ClientData) channel);
+
+    /*
+     * 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 ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
+      FlushChannel(NULL, chanPtr, 1);
+      mask &= ~TCL_WRITABLE;
+    }
+
+    /*
+     * Add this invocation to the list of recursive invocations of
+     * ChannelHandlerEventProc.
+     */
+    
+    nh.nextHandlerPtr = (ChannelHandler *) NULL;
+    nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
+    tsdPtr->nestedHandlerPtr = &nh;
+
+    for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) 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, 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) {
+        UpdateInterest(chanPtr);
+    }
+
+    Tcl_Release((ClientData) channel);
+
+    tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr;
+#else
     /* Walk all channels in a stack ! and notify them in order.
      */
 
-    while (chanPtr !=  (Channel *) NULL) {
-	/*
+    while (chanPtr != (Channel *) NULL) {
+        /*
 	 * Preserve the channel struct in case the script closes it.
 	 */
      
-	Tcl_Preserve((ClientData) channel);
+        Tcl_Preserve((ClientData) channel);
 
 	/*
 	 * If we are flushing in the background, be sure to call FlushChannel
-	 * for writable events.	 Note that we have to discard the writable
+	 * 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 ((chanPtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
+	if ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
 	    FlushChannel(NULL, chanPtr, 1);
 	    mask &= ~TCL_WRITABLE;
 	}
@@ -6065,21 +6328,21 @@ Tcl_NotifyChannel(channel, mask)
 	nh.nextHandlerPtr = (ChannelHandler *) NULL;
 	nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
 	tsdPtr->nestedHandlerPtr = &nh;
-    
-	for (chPtr = chanPtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
+
+	for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) 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, mask);
-	      chPtr = nh.nextHandlerPtr;
-	  } else {
-	      chPtr = chPtr->nextPtr;
-	  }
+        
+	    if ((chPtr->mask & mask) != 0) {
+		nh.nextHandlerPtr = chPtr->nextPtr;
+		(*(chPtr->proc))(chPtr->clientData, mask);
+		chPtr = nh.nextHandlerPtr;
+	    } else {
+		chPtr = chPtr->nextPtr;
+	    }
 	}
 
 	/*
@@ -6093,11 +6356,11 @@ Tcl_NotifyChannel(channel, mask)
 
 	    /* Walk down the stack.
 	     */
-	  chanPtr = chanPtr-> supercedes;
+	    chanPtr = chanPtr->downChanPtr;
 	} else {
 	    /* Stop walking the chain, the whole stack was destroyed!
 	     */
-	    chanPtr = (Channel*) NULL;
+	    chanPtr = (Channel *) NULL;
 	}
 
 	Tcl_Release((ClientData) channel);
@@ -6106,6 +6369,7 @@ Tcl_NotifyChannel(channel, mask)
 
 	channel = (Tcl_Channel) chanPtr;
     }
+#endif
 }
 
 /*
@@ -6129,14 +6393,15 @@ static void
 UpdateInterest(chanPtr)
     Channel *chanPtr;		/* Channel to update. */
 {
-    int mask = chanPtr->interestMask;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    int mask = statePtr->interestMask;
 
     /*
      * If there are flushed buffers waiting to be written, then
      * we need to watch for the channel to become writable.
      */
 
-    if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
+    if (statePtr->flags & BG_FLUSH_SCHEDULED) {
 	mask |= TCL_WRITABLE;
     }
 
@@ -6148,13 +6413,13 @@ UpdateInterest(chanPtr)
      */
 
     if (mask & TCL_READABLE) {
-	if (!(chanPtr->flags & CHANNEL_NEED_MORE_DATA)
-		&& (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
-		&& (chanPtr->inQueueHead->nextRemoved <
-			chanPtr->inQueueHead->nextAdded)) {
+	if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
+		&& (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+		&& (statePtr->inQueueHead->nextRemoved <
+			statePtr->inQueueHead->nextAdded)) {
 	    mask &= ~TCL_READABLE;
-	    if (!chanPtr->timer) {
-		chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
+	    if (!statePtr->timer) {
+		statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
 			(ClientData) chanPtr);
 	    }
 	}
@@ -6184,23 +6449,24 @@ ChannelTimerProc(clientData)
     ClientData clientData;
 {
     Channel *chanPtr = (Channel *) clientData;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
 
-    if (!(chanPtr->flags & CHANNEL_NEED_MORE_DATA)
-	    && (chanPtr->interestMask & TCL_READABLE)
-	    && (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
-	    && (chanPtr->inQueueHead->nextRemoved <
-		    chanPtr->inQueueHead->nextAdded)) {
+    if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
+	    && (statePtr->interestMask & TCL_READABLE)
+	    && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+	    && (statePtr->inQueueHead->nextRemoved <
+		    statePtr->inQueueHead->nextAdded)) {
 	/*
 	 * Restart the timer in case a channel handler reenters the
 	 * event loop before UpdateInterest gets called by Tcl_NotifyChannel.
 	 */
 
-	chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
-			(ClientData) chanPtr);
+	statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
+		(ClientData) chanPtr);
 	Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE);
  
-   } else {
-	chanPtr->timer = NULL;
+    } else {
+	statePtr->timer = NULL;
 	UpdateInterest(chanPtr);
     }
 }
@@ -6234,38 +6500,37 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
 				 * TCL_WRITABLE, and TCL_EXCEPTION:
 				 * indicates conditions under which
 				 * proc should be called. Use 0 to
-				 * disable a registered handler. */
+                                 * 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 *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
 
-    chanPtr = (Channel *) chan;
-    
     /*
      * 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 = chanPtr->chPtr;
-	     chPtr != (ChannelHandler *) NULL;
-	     chPtr = chPtr->nextPtr) {
-	if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
-		(chPtr->clientData == clientData)) {
-	    break;
-	}
+    for (chPtr = statePtr->chPtr;
+	 chPtr != (ChannelHandler *) NULL;
+	 chPtr = chPtr->nextPtr) {
+        if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
+                (chPtr->clientData == clientData)) {
+            break;
+        }
     }
     if (chPtr == (ChannelHandler *) NULL) {
-	chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
-	chPtr->mask = 0;
-	chPtr->proc = proc;
-	chPtr->clientData = clientData;
-	chPtr->chanPtr = chanPtr;
-	chPtr->nextPtr = chanPtr->chPtr;
-	chanPtr->chPtr = chPtr;
+        chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
+        chPtr->mask = 0;
+        chPtr->proc = proc;
+        chPtr->clientData = clientData;
+        chPtr->chanPtr = chanPtr;
+        chPtr->nextPtr = statePtr->chPtr;
+        statePtr->chPtr = chPtr;
     }
 
     /*
@@ -6281,14 +6546,14 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
      * be disabling an existing handler.
      */
     
-    chanPtr->interestMask = 0;
-    for (chPtr = chanPtr->chPtr;
+    statePtr->interestMask = 0;
+    for (chPtr = statePtr->chPtr;
 	 chPtr != (ChannelHandler *) NULL;
 	 chPtr = chPtr->nextPtr) {
-	chanPtr->interestMask |= chPtr->mask;
+	statePtr->interestMask |= chPtr->mask;
     }
 
-    UpdateInterest(chanPtr);
+    UpdateInterest(statePtr->topChanPtr);
 }
 
 /*
@@ -6313,39 +6578,38 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
 void
 Tcl_DeleteChannelHandler(chan, proc, clientData)
     Tcl_Channel chan;		/* The channel for which to remove the
-				 * callback. */
+                                 * callback. */
     Tcl_ChannelProc *proc;	/* The procedure in the callback to delete. */
     ClientData clientData;	/* The client data in the callback
-				 * to delete. */
+                                 * to delete. */
     
 {
-    ChannelHandler *chPtr, *prevChPtr;
-    Channel *chanPtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelHandler *chPtr, *prevChPtr;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     NextChannelHandler *nhPtr;
 
-    chanPtr = (Channel *) chan;
-
     /*
      * Find the entry and the previous one in the list.
      */
 
-    for (prevChPtr = (ChannelHandler *) NULL, chPtr = chanPtr->chPtr;
-	     chPtr != (ChannelHandler *) NULL;
-	     chPtr = chPtr->nextPtr) {
-	if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
-		&& (chPtr->proc == proc)) {
-	    break;
-	}
-	prevChPtr = chPtr;
+    for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr;
+	 chPtr != (ChannelHandler *) 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 == (ChannelHandler *) NULL) {
-	return;
+        return;
     }
 
     /*
@@ -6354,11 +6618,11 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
      */
 
     for (nhPtr = tsdPtr->nestedHandlerPtr;
-	     nhPtr != (NextChannelHandler *) NULL;
-	     nhPtr = nhPtr->nestedHandlerPtr) {
-	if (nhPtr->nextHandlerPtr == chPtr) {
-	    nhPtr->nextHandlerPtr = chPtr->nextPtr;
-	}
+	 nhPtr != (NextChannelHandler *) NULL;
+	 nhPtr = nhPtr->nestedHandlerPtr) {
+        if (nhPtr->nextHandlerPtr == chPtr) {
+            nhPtr->nextHandlerPtr = chPtr->nextPtr;
+        }
     }
 
     /*
@@ -6366,9 +6630,9 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
      */
     
     if (prevChPtr == (ChannelHandler *) NULL) {
-	chanPtr->chPtr = chPtr->nextPtr;
+        statePtr->chPtr = chPtr->nextPtr;
     } else {
-	prevChPtr->nextPtr = chPtr->nextPtr;
+        prevChPtr->nextPtr = chPtr->nextPtr;
     }
     ckfree((char *) chPtr);
 
@@ -6378,14 +6642,14 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
      * event.
      */
 
-    chanPtr->interestMask = 0;
-    for (chPtr = chanPtr->chPtr;
-	     chPtr != (ChannelHandler *) NULL;
-	     chPtr = chPtr->nextPtr) {
-	chanPtr->interestMask |= chPtr->mask;
+    statePtr->interestMask = 0;
+    for (chPtr = statePtr->chPtr;
+	 chPtr != (ChannelHandler *) NULL;
+	 chPtr = chPtr->nextPtr) {
+        statePtr->interestMask |= chPtr->mask;
     }
 
-    UpdateInterest(chanPtr);
+    UpdateInterest(statePtr->topChanPtr);
 }
 
 /*
@@ -6408,33 +6672,34 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
 static void
 DeleteScriptRecord(interp, chanPtr, mask)
     Tcl_Interp *interp;		/* Interpreter in which script was to be
-				 * executed. */
+                                 * executed. */
     Channel *chanPtr;		/* The channel for which to delete the
-				 * script record (if any). */
+                                 * script record (if any). */
     int mask;			/* Events in mask must exactly match mask
-				 * of script to delete. */
+                                 * of script to delete. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     EventScriptRecord *esPtr, *prevEsPtr;
 
-    for (esPtr = chanPtr->scriptRecordPtr,
-	     prevEsPtr = (EventScriptRecord *) NULL;
-	     esPtr != (EventScriptRecord *) NULL;
-	     prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
-	if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
-	    if (esPtr == chanPtr->scriptRecordPtr) {
-		chanPtr->scriptRecordPtr = esPtr->nextPtr;
-	    } else {
-		prevEsPtr->nextPtr = esPtr->nextPtr;
-	    }
+    for (esPtr = statePtr->scriptRecordPtr,
+             prevEsPtr = (EventScriptRecord *) NULL;
+	 esPtr != (EventScriptRecord *) NULL;
+	 prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
+        if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+            if (esPtr == statePtr->scriptRecordPtr) {
+                statePtr->scriptRecordPtr = esPtr->nextPtr;
+            } else {
+                prevEsPtr->nextPtr = esPtr->nextPtr;
+            }
 
-	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
-		    TclChannelEventScriptInvoker, (ClientData) esPtr);
-	    
+            Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+                    TclChannelEventScriptInvoker, (ClientData) esPtr);
+            
 	    Tcl_DecrRefCount(esPtr->scriptPtr);
-	    ckfree((char *) esPtr);
+            ckfree((char *) esPtr);
 
-	    break;
-	}
+            break;
+        }
     }
 }
 
@@ -6458,31 +6723,32 @@ DeleteScriptRecord(interp, chanPtr, mask)
 static void
 CreateScriptRecord(interp, chanPtr, mask, scriptPtr)
     Tcl_Interp *interp;			/* Interpreter in which to execute
-					 * the stored script. */
+                                         * the stored script. */
     Channel *chanPtr;			/* Channel for which script is to
-					 * be stored. */
+                                         * be stored. */
     int mask;				/* Set of events for which script
-					 * will be invoked. */
+                                         * will be invoked. */
     Tcl_Obj *scriptPtr;			/* Pointer to script object. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     EventScriptRecord *esPtr;
 
-    for (esPtr = chanPtr->scriptRecordPtr;
-	     esPtr != (EventScriptRecord *) NULL;
-	     esPtr = esPtr->nextPtr) {
-	if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+    for (esPtr = statePtr->scriptRecordPtr;
+	 esPtr != (EventScriptRecord *) NULL;
+	 esPtr = esPtr->nextPtr) {
+        if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
 	    Tcl_DecrRefCount(esPtr->scriptPtr);
 	    esPtr->scriptPtr = (Tcl_Obj *) NULL;
-	    break;
-	}
+            break;
+        }
     }
     if (esPtr == (EventScriptRecord *) NULL) {
-	esPtr = (EventScriptRecord *) ckalloc((unsigned)
-		sizeof(EventScriptRecord));
-	Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
-		TclChannelEventScriptInvoker, (ClientData) esPtr);
-	esPtr->nextPtr = chanPtr->scriptRecordPtr;
-	chanPtr->scriptRecordPtr = esPtr;
+        esPtr = (EventScriptRecord *) ckalloc((unsigned)
+                sizeof(EventScriptRecord));
+        Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
+                TclChannelEventScriptInvoker, (ClientData) esPtr);
+        esPtr->nextPtr = statePtr->scriptRecordPtr;
+        statePtr->scriptRecordPtr = esPtr;
     }
     esPtr->chanPtr = chanPtr;
     esPtr->interp = interp;
@@ -6516,17 +6782,16 @@ TclChannelEventScriptInvoker(clientData, mask)
 {
     Tcl_Interp *interp;		/* Interpreter in which to eval the script. */
     Channel *chanPtr;		/* The channel for which this handler is
-				 * registered. */
+                                 * registered. */
     EventScriptRecord *esPtr;	/* The event script + interpreter to eval it
-				 * in. */
+                                 * in. */
     int result;			/* Result of call to eval script. */
 
-    esPtr = (EventScriptRecord *) clientData;
+    esPtr	= (EventScriptRecord *) clientData;
+    chanPtr	= esPtr->chanPtr;
+    mask	= esPtr->mask;
+    interp	= esPtr->interp;
 
-    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
@@ -6548,7 +6813,7 @@ TclChannelEventScriptInvoker(clientData, mask)
 	if (chanPtr->typePtr != NULL) {
 	    DeleteScriptRecord(interp, chanPtr, mask);
 	}
-	Tcl_BackgroundError(interp);
+        Tcl_BackgroundError(interp);
     }
     Tcl_Release((ClientData) interp);
 }
@@ -6577,13 +6842,14 @@ int
 Tcl_FileEventObjCmd(clientData, interp, objc, objv)
     ClientData clientData;		/* Not used. */
     Tcl_Interp *interp;			/* Interpreter in which the channel
-					 * for which to create the handler
-					 * is found. */
+                                         * 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. */
+                                         * the handler for. */
+    ChannelState *statePtr;		/* state info for channel */
     Tcl_Channel chan;			/* The opaque type for the channel. */
     char *chanName;
     int modeIndex;			/* Index of mode argument. */
@@ -6606,12 +6872,13 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
     if (chan == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
-    chanPtr = (Channel *) chan;
-    if ((chanPtr->flags & mask) == 0) {
-	Tcl_AppendResult(interp, "channel is not ",
-		(mask == TCL_READABLE) ? "readable" : "writable",
-		(char *) NULL);
-	return TCL_ERROR;
+    chanPtr  = (Channel *) chan;
+    statePtr = chanPtr->state;
+    if ((statePtr->flags & mask) == 0) {
+        Tcl_AppendResult(interp, "channel is not ",
+                (mask == TCL_READABLE) ? "readable" : "writable",
+                (char *) NULL);
+        return TCL_ERROR;
     }
     
     /*
@@ -6620,15 +6887,15 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
 
     if (objc == 3) {
 	EventScriptRecord *esPtr;
-	for (esPtr = chanPtr->scriptRecordPtr;
-	     esPtr != (EventScriptRecord *) NULL;
-	     esPtr = esPtr->nextPtr) {
+	for (esPtr = statePtr->scriptRecordPtr;
+             esPtr != (EventScriptRecord *) NULL;
+             esPtr = esPtr->nextPtr) {
 	    if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
 		Tcl_SetObjResult(interp, esPtr->scriptPtr);
 		break;
 	    }
 	}
-	return TCL_OK;
+        return TCL_OK;
     }
 
     /*
@@ -6636,8 +6903,8 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
      */
 
     if (*(Tcl_GetString(objv[3])) == '\0') {
-	DeleteScriptRecord(interp, chanPtr, mask);
-	return TCL_OK;
+        DeleteScriptRecord(interp, chanPtr, mask);
+        return TCL_OK;
     }
 
     /*
@@ -6658,7 +6925,7 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
  *
  *	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
+ *	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.
  *
@@ -6682,26 +6949,30 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
 {
     Channel *inPtr = (Channel *) inChan;
     Channel *outPtr = (Channel *) outChan;
+    ChannelState *inStatePtr, *outStatePtr;
     int readFlags, writeFlags;
     CopyState *csPtr;
     int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
 
-    if (inPtr->csPtr) {
+    inStatePtr	= inPtr->state;
+    outStatePtr	= outPtr->state;
+
+    if (inStatePtr->csPtr) {
 	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
 		Tcl_GetChannelName(inChan), "\" is busy", NULL);
 	return TCL_ERROR;
     }
-    if (outPtr->csPtr) {
+    if (outStatePtr->csPtr) {
 	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
 		Tcl_GetChannelName(outChan), "\" is busy", NULL);
 	return TCL_ERROR;
     }
 
-    readFlags = inPtr->flags;
-    writeFlags = outPtr->flags;
+    readFlags	= inStatePtr->flags;
+    writeFlags	= outStatePtr->flags;
 
     /*
-     * Set up the blocking mode appropriately.	Background copies need
+     * 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.
      */
@@ -6732,7 +7003,7 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
      * Make sure the output side is unbuffered.
      */
 
-    outPtr->flags = (outPtr->flags & ~(CHANNEL_LINEBUFFERED))
+    outStatePtr->flags = (outStatePtr->flags & ~(CHANNEL_LINEBUFFERED))
 	| CHANNEL_UNBUFFERED;
 
     /*
@@ -6741,21 +7012,21 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
      * completed.
      */
 
-    csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inPtr->bufSize);
-    csPtr->bufSize = inPtr->bufSize;
-    csPtr->readPtr = inPtr;
-    csPtr->writePtr = outPtr;
-    csPtr->readFlags = readFlags;
+    csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inStatePtr->bufSize);
+    csPtr->bufSize    = inStatePtr->bufSize;
+    csPtr->readPtr    = inPtr;
+    csPtr->writePtr   = outPtr;
+    csPtr->readFlags  = readFlags;
     csPtr->writeFlags = writeFlags;
-    csPtr->toRead = toRead;
-    csPtr->total = 0;
-    csPtr->interp = interp;
+    csPtr->toRead     = toRead;
+    csPtr->total      = 0;
+    csPtr->interp     = interp;
     if (cmdPtr) {
 	Tcl_IncrRefCount(cmdPtr);
     }
     csPtr->cmdPtr = cmdPtr;
-    inPtr->csPtr = csPtr;
-    outPtr->csPtr = csPtr;
+    inStatePtr->csPtr = csPtr;
+    outStatePtr->csPtr = csPtr;
 
     /*
      * Start copying data between the channels.
@@ -6789,17 +7060,24 @@ CopyData(csPtr, mask)
     Tcl_Interp *interp;
     Tcl_Obj *cmdPtr, *errObj = NULL;
     Tcl_Channel inChan, outChan;
+    ChannelState *inStatePtr, *outStatePtr;
     int result = TCL_OK;
     int size;
     int total;
 
-    inChan = (Tcl_Channel)csPtr->readPtr;
-    outChan = (Tcl_Channel)csPtr->writePtr;
-    interp = csPtr->interp;
-    cmdPtr = csPtr->cmdPtr;
+    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.
      */
 
     while (csPtr->toRead != 0) {
@@ -6808,14 +7086,14 @@ CopyData(csPtr, mask)
 	 * Check for unreported background errors.
 	 */
 
-	if (csPtr->readPtr->unreportedError != 0) {
-	    Tcl_SetErrno(csPtr->readPtr->unreportedError);
-	    csPtr->readPtr->unreportedError = 0;
+	if (inStatePtr->unreportedError != 0) {
+	    Tcl_SetErrno(inStatePtr->unreportedError);
+	    inStatePtr->unreportedError = 0;
 	    goto readError;
 	}
-	if (csPtr->writePtr->unreportedError != 0) {
-	    Tcl_SetErrno(csPtr->writePtr->unreportedError);
-	    csPtr->writePtr->unreportedError = 0;
+	if (outStatePtr->unreportedError != 0) {
+	    Tcl_SetErrno(outStatePtr->unreportedError);
+	    outStatePtr->unreportedError = 0;
 	    goto writeError;
 	}
 	
@@ -6823,13 +7101,12 @@ CopyData(csPtr, mask)
 	 * Read up to bufSize bytes.
 	 */
 
-	if ((csPtr->toRead == -1)
-		|| (csPtr->toRead > csPtr->bufSize)) {
+	if ((csPtr->toRead == -1) || (csPtr->toRead > csPtr->bufSize)) {
 	    size = csPtr->bufSize;
 	} else {
 	    size = csPtr->toRead;
 	}
-	size = DoRead(csPtr->readPtr, csPtr->buffer, size);
+	size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, size);
 
 	if (size < 0) {
 	    readError:
@@ -6862,7 +7139,7 @@ CopyData(csPtr, mask)
 	 * Now write the buffer out.
 	 */
 
-	size = DoWrite(csPtr->writePtr, csPtr->buffer, size);
+	size = DoWrite(outStatePtr->topChanPtr, csPtr->buffer, size);
 	if (size < 0) {
 	    writeError:
 	    errObj = Tcl_NewObj();
@@ -6877,7 +7154,7 @@ CopyData(csPtr, mask)
 	 * stop copying and wait for the channel to become writable again.
 	 */
 
-	if (csPtr->writePtr->flags & BG_FLUSH_SCHEDULED) {
+	if (outStatePtr->flags & BG_FLUSH_SCHEDULED) {
 	    if (!(mask & TCL_WRITABLE)) {
 		if (mask & TCL_READABLE) {
 		    Tcl_DeleteChannelHandler(outChan, CopyEventProc,
@@ -6926,7 +7203,7 @@ CopyData(csPtr, mask)
     if (cmdPtr) {
 	/*
 	 * Get a private copy of the command so we can mutate it
-	 * by adding arguments.	 Note that StopCopy frees our saved
+	 * by adding arguments.  Note that StopCopy frees our saved
 	 * reference to the original command obj.
 	 */
 
@@ -6981,47 +7258,48 @@ DoRead(chanPtr, bufPtr, toRead)
     char *bufPtr;		/* Where to store input read. */
     int toRead;			/* Maximum number of bytes to read. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     int copied;			/* How many characters were copied into
-				 * the result string? */
+                                 * the result string? */
     int copiedNow;		/* How many characters were copied from
-				 * the current input buffer? */
+                                 * the current input buffer? */
     int result;			/* Of calling GetInput. */
-    
+
     /*
      * If we have not encountered a sticky EOF, clear the EOF bit. Either
      * way clear the BLOCKED bit. We want to discover these anew during
      * each operation.
      */
 
-    if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
-	chanPtr->flags &= ~CHANNEL_EOF;
+    if (!(statePtr->flags & CHANNEL_STICKY_EOF)) {
+        statePtr->flags &= ~CHANNEL_EOF;
     }
-    chanPtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+    statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
     
     for (copied = 0; copied < toRead; copied += copiedNow) {
-	copiedNow = CopyAndTranslateBuffer(chanPtr, bufPtr + copied,
-		toRead - copied);
-	if (copiedNow == 0) {
-	    if (chanPtr->flags & CHANNEL_EOF) {
+        copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied,
+                toRead - copied);
+        if (copiedNow == 0) {
+            if (statePtr->flags & CHANNEL_EOF) {
 		goto done;
-	    }
-	    if (chanPtr->flags & CHANNEL_BLOCKED) {
-		if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+            }
+            if (statePtr->flags & CHANNEL_BLOCKED) {
+                if (statePtr->flags & CHANNEL_NONBLOCKING) {
 		    goto done;
-		}
-		chanPtr->flags &= (~(CHANNEL_BLOCKED));
-	    }
-	    result = GetInput(chanPtr);
-	    if (result != 0) {
-		if (result != EAGAIN) {
-		    copied = -1;
-		}
+                }
+                statePtr->flags &= (~(CHANNEL_BLOCKED));
+            }
+            result = GetInput(chanPtr);
+            if (result != 0) {
+                if (result != EAGAIN) {
+                    copied = -1;
+                }
 		goto done;
-	    }
-	}
+            }
+        }
     }
 
-    chanPtr->flags &= (~(CHANNEL_BLOCKED));
+    statePtr->flags &= (~(CHANNEL_BLOCKED));
 
     done:
     /*
@@ -7053,17 +7331,17 @@ DoRead(chanPtr, bufPtr, toRead)
  */
 
 static int
-CopyAndTranslateBuffer(chanPtr, result, space)
-    Channel *chanPtr;		/* The channel from which to read input. */
+CopyAndTranslateBuffer(statePtr, result, space)
+    ChannelState *statePtr;	/* Channel state from which to read input. */
     char *result;		/* Where to store the copied input. */
     int space;			/* How many bytes are available in result
                                  * to store the copied input? */
 {
+    ChannelBuffer *bufPtr;	/* The buffer from which to copy bytes. */
     int bytesInBuffer;		/* How many bytes are available to be
                                  * copied in the current input buffer? */
     int copied;			/* How many characters were already copied
                                  * into the destination space? */
-    ChannelBuffer *bufPtr;	/* The buffer from which to copy bytes. */
     int i;			/* Iterates over the copied input looking
                                  * for the input eofChar. */
     
@@ -7074,14 +7352,14 @@ CopyAndTranslateBuffer(chanPtr, result, space)
      * Note also that if the buffer is empty, we leave it in the queue.
      */
     
-    if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+    if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
         return 0;
     }
-    bufPtr = chanPtr->inQueueHead;
+    bufPtr = statePtr->inQueueHead;
     bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
 
     copied = 0;
-    switch (chanPtr->inputTranslation) {
+    switch (statePtr->inputTranslation) {
         case TCL_TRANSLATE_LF: {
             if (bytesInBuffer == 0) {
                 return 0;
@@ -7138,10 +7416,10 @@ CopyAndTranslateBuffer(chanPtr, result, space)
              */
             
 	    if (bytesInBuffer == 0) {
-                if ((chanPtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
+                if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
                         (INPUT_SAW_CR | CHANNEL_EOF)) {
                     result[0] = '\r';
-                    chanPtr->flags &= ~INPUT_SAW_CR;
+                    statePtr->flags &= ~INPUT_SAW_CR;
                     return 1;
                 }
                 return 0;
@@ -7166,14 +7444,14 @@ CopyAndTranslateBuffer(chanPtr, result, space)
 	    for (src = result; src < end; src++) {
 		curByte = *src;
 		if (curByte == '\n') {
-                    chanPtr->flags &= ~INPUT_SAW_CR;
-		} else if (chanPtr->flags & INPUT_SAW_CR) {
-		    chanPtr->flags &= ~INPUT_SAW_CR;
+                    statePtr->flags &= ~INPUT_SAW_CR;
+		} else if (statePtr->flags & INPUT_SAW_CR) {
+		    statePtr->flags &= ~INPUT_SAW_CR;
 		    *dst = '\r';
 		    dst++;
 		}
 		if (curByte == '\r') {
-		    chanPtr->flags |= INPUT_SAW_CR;
+		    statePtr->flags |= INPUT_SAW_CR;
 		} else {
 		    *dst = (char) curByte;
 		    dst++;
@@ -7209,16 +7487,16 @@ CopyAndTranslateBuffer(chanPtr, result, space)
 	    for (src = result; src < end; src++) {
 		curByte = *src;
 		if (curByte == '\r') {
-		    chanPtr->flags |= INPUT_SAW_CR;
+		    statePtr->flags |= INPUT_SAW_CR;
 		    *dst = '\n';
 		    dst++;
 		} else {
 		    if ((curByte != '\n') || 
-			    !(chanPtr->flags & INPUT_SAW_CR)) {
+			    !(statePtr->flags & INPUT_SAW_CR)) {
 			*dst = (char) curByte;
 			dst++;
 		    }
-		    chanPtr->flags &= ~INPUT_SAW_CR;
+		    statePtr->flags &= ~INPUT_SAW_CR;
 		}
 	    }
 	    copied = dst - result;
@@ -7235,16 +7513,16 @@ CopyAndTranslateBuffer(chanPtr, result, space)
      * copy only up to and excluding that character.
      */
     
-    if (chanPtr->inEofChar != 0) {
+    if (statePtr->inEofChar != 0) {
         for (i = 0; i < copied; i++) {
-            if (result[i] == (char) chanPtr->inEofChar) {
+            if (result[i] == (char) statePtr->inEofChar) {
 		/*
 		 * Set sticky EOF so that no further input is presented
 		 * to the caller.
 		 */
 		
-		chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
-		chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+		statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+		statePtr->inputEncodingFlags |= TCL_ENCODING_END;
 		copied = i;
                 break;
             }
@@ -7256,17 +7534,109 @@ CopyAndTranslateBuffer(chanPtr, result, space)
      */
 
     if (bufPtr->nextRemoved == bufPtr->nextAdded) {
+        statePtr->inQueueHead = bufPtr->nextPtr;
+        if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+            statePtr->inQueueTail = (ChannelBuffer *) NULL;
+        }
+        RecycleBuffer(statePtr, bufPtr, 0);
+    }
+
+    /*
+     * Return the number of characters copied into the result buffer.
+     * This may be different from the number of bytes consumed, because
+     * of EOL translations.
+     */
+
+    return copied;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CopyBuffer --
+ *
+ *	Copy at most one buffer of input to the result space.
+ *
+ * Results:
+ *	Number of bytes stored in the result buffer.  May return
+ *	zero if no input is available.
+ *
+ * Side effects:
+ *	Consumes buffered input. May deallocate one buffer.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CopyBuffer(chanPtr, result, space)
+    Channel *chanPtr;		/* Channel from which to read input. */
+    char *result;		/* Where to store the copied input. */
+    int space;			/* How many bytes are available in result
+                                 * to store the copied input? */
+{
+    ChannelBuffer *bufPtr;	/* The buffer from which to copy bytes. */
+    int bytesInBuffer;		/* How many bytes are available to be
+                                 * copied in the current input buffer? */
+    int copied;			/* How many characters were already copied
+                                 * into the destination space? */
+    
+    /*
+     * If there is no input at all, return zero. The invariant is that
+     * either there is no buffer in the queue, or if the first buffer
+     * is empty, it is also the last buffer (and thus there is no
+     * input in the queue).  Note also that if the buffer is empty, we
+     * don't leave it in the queue, but recycle it.
+     */
+    
+    if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+        return 0;
+    }
+    bufPtr = chanPtr->inQueueHead;
+    bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
+
+    copied = 0;
+
+    if (bytesInBuffer == 0) {
+        RecycleBuffer(chanPtr->state, bufPtr, 0);
+	chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+	chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+        return 0;
+    }
+
+    /*
+     * Copy the current chunk into the result buffer.
+     */
+
+    if (bytesInBuffer < space) {
+        space = bytesInBuffer;
+    }
+
+    memcpy((VOID *) result,
+	   (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
+	   (size_t) space);
+    bufPtr->nextRemoved += space;
+    copied = space;
+
+    /*
+     * We don't care about in-stream EOF characters here as the data
+     * read here may still flow through one or more transformations,
+     * i.e. is not in its final state yet.
+     */
+
+    /*
+     * If the current buffer is empty recycle it.
+     */
+
+    if (bufPtr->nextRemoved == bufPtr->nextAdded) {
         chanPtr->inQueueHead = bufPtr->nextPtr;
         if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
             chanPtr->inQueueTail = (ChannelBuffer *) NULL;
         }
-        RecycleBuffer(chanPtr, bufPtr, 0);
+        RecycleBuffer(chanPtr->state, bufPtr, 0);
     }
 
     /*
      * Return the number of characters copied into the result buffer.
-     * This may be different from the number of bytes consumed, because
-     * of EOL translations.
      */
 
     return copied;
@@ -7299,22 +7669,23 @@ DoWrite(chanPtr, src, srcLen)
     char *src;				/* Data to write. */
     int srcLen;				/* Number of bytes to write. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     ChannelBuffer *outBufPtr;		/* Current output buffer. */
     int foundNewline;			/* Did we find a newline in output? */
     char *dPtr;
     char *sPtr;				/* Search variables for newline. */
     int crsent;				/* In CRLF eol translation mode,
-					 * remember the fact that a CR was
-					 * output to the channel without
-					 * its following NL. */
+                                         * remember the fact that a CR was
+                                         * output to the channel without
+                                         * its following NL. */
     int i;				/* Loop index for newline search. */
     int destCopied;			/* How many bytes were used in this
-					 * destination buffer to hold the
-					 * output? */
+                                         * destination buffer to hold the
+                                         * output? */
     int totalDestCopied;		/* How many bytes total were
-					 * copied to the channel buffer? */
+                                         * copied to the channel buffer? */
     int srcCopied;			/* How many bytes were copied from
-					 * the source string? */
+                                         * the source string? */
     char *destPtr;			/* Where in line to copy to? */
 
     /*
@@ -7333,97 +7704,97 @@ DoWrite(chanPtr, src, srcLen)
     totalDestCopied = 0;
 
     while (srcLen > 0) {
-	
-	/*
-	 * Make sure there is a current output buffer to accept output.
-	 */
+        
+        /*
+         * Make sure there is a current output buffer to accept output.
+         */
 
-	if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
-	    chanPtr->curOutPtr = AllocChannelBuffer(chanPtr->bufSize);
-	}
+        if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+            statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
+        }
 
-	outBufPtr = chanPtr->curOutPtr;
+        outBufPtr = statePtr->curOutPtr;
 
-	destCopied = outBufPtr->bufLength - outBufPtr->nextAdded;
-	if (destCopied > srcLen) {
-	    destCopied = srcLen;
-	}
-	
-	destPtr = outBufPtr->buf + outBufPtr->nextAdded;
-	switch (chanPtr->outputTranslation) {
-	    case TCL_TRANSLATE_LF:
-		srcCopied = destCopied;
-		memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
-		break;
-	    case TCL_TRANSLATE_CR:
-		srcCopied = destCopied;
-		memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
-		for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
-		    if (*dPtr == '\n') {
-			*dPtr = '\r';
-		    }
-		}
-		break;
-	    case TCL_TRANSLATE_CRLF:
-		for (srcCopied = 0, dPtr = destPtr, sPtr = src;
-		     dPtr < destPtr + destCopied;
-		     dPtr++, sPtr++, srcCopied++) {
-		    if (*sPtr == '\n') {
-			if (crsent) {
-			    *dPtr = '\n';
-			    crsent = 0;
-			} else {
-			    *dPtr = '\r';
-			    crsent = 1;
-			    sPtr--, srcCopied--;
-			}
-		    } else {
-			*dPtr = *sPtr;
-		    }
-		}
-		break;
-	    case TCL_TRANSLATE_AUTO:
-		panic("Tcl_Write: AUTO output translation mode not supported");
-	    default:
-		panic("Tcl_Write: unknown output translation mode");
-	}
+        destCopied = outBufPtr->bufLength - outBufPtr->nextAdded;
+        if (destCopied > srcLen) {
+            destCopied = srcLen;
+        }
+        
+        destPtr = outBufPtr->buf + outBufPtr->nextAdded;
+        switch (statePtr->outputTranslation) {
+            case TCL_TRANSLATE_LF:
+                srcCopied = destCopied;
+                memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+                break;
+            case TCL_TRANSLATE_CR:
+                srcCopied = destCopied;
+                memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+                for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
+                    if (*dPtr == '\n') {
+                        *dPtr = '\r';
+                    }
+                }
+                break;
+            case TCL_TRANSLATE_CRLF:
+                for (srcCopied = 0, dPtr = destPtr, sPtr = src;
+                     dPtr < destPtr + destCopied;
+                     dPtr++, sPtr++, srcCopied++) {
+                    if (*sPtr == '\n') {
+                        if (crsent) {
+                            *dPtr = '\n';
+                            crsent = 0;
+                        } else {
+                            *dPtr = '\r';
+                            crsent = 1;
+                            sPtr--, srcCopied--;
+                        }
+                    } else {
+                        *dPtr = *sPtr;
+                    }
+                }
+                break;
+            case TCL_TRANSLATE_AUTO:
+                panic("Tcl_Write: AUTO output translation mode not supported");
+            default:
+                panic("Tcl_Write: unknown output translation mode");
+        }
 
-	/*
-	 * The current buffer is ready for output if it is full, or if it
-	 * contains a newline and this channel is line-buffered, or if it
-	 * contains any output and this channel is unbuffered.
-	 */
+        /*
+         * The current buffer is ready for output if it is full, or if it
+         * contains a newline and this channel is line-buffered, or if it
+         * contains any output and this channel is unbuffered.
+         */
 
-	outBufPtr->nextAdded += destCopied;
-	if (!(chanPtr->flags & BUFFER_READY)) {
-	    if (outBufPtr->nextAdded == outBufPtr->bufLength) {
-		chanPtr->flags |= BUFFER_READY;
-	    } else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
-		for (sPtr = src, i = 0, foundNewline = 0;
+        outBufPtr->nextAdded += destCopied;
+        if (!(statePtr->flags & BUFFER_READY)) {
+            if (outBufPtr->nextAdded == outBufPtr->bufLength) {
+                statePtr->flags |= BUFFER_READY;
+            } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
+                for (sPtr = src, i = 0, foundNewline = 0;
 		     (i < srcCopied) && (!foundNewline);
 		     i++, sPtr++) {
-		    if (*sPtr == '\n') {
-			foundNewline = 1;
-			break;
-		    }
-		}
-		if (foundNewline) {
-		    chanPtr->flags |= BUFFER_READY;
-		}
-	    } else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
-		chanPtr->flags |= BUFFER_READY;
-	    }
-	}
-	
-	totalDestCopied += srcCopied;
-	src += srcCopied;
-	srcLen -= srcCopied;
+                    if (*sPtr == '\n') {
+                        foundNewline = 1;
+                        break;
+                    }
+                }
+                if (foundNewline) {
+                    statePtr->flags |= BUFFER_READY;
+                }
+            } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
+                statePtr->flags |= BUFFER_READY;
+            }
+        }
+        
+        totalDestCopied += srcCopied;
+        src += srcCopied;
+        srcLen -= srcCopied;
 
-	if (chanPtr->flags & BUFFER_READY) {
-	    if (FlushChannel(NULL, chanPtr, 0) != 0) {
-		return -1;
-	    }
-	}
+        if (statePtr->flags & BUFFER_READY) {
+            if (FlushChannel(NULL, chanPtr, 0) != 0) {
+                return -1;
+            }
+        }
     } /* Closes "while" */
 
     return totalDestCopied;
@@ -7435,7 +7806,7 @@ DoWrite(chanPtr, src, srcLen)
  * CopyEventProc --
  *
  *	This routine is invoked as a channel event handler for
- *	the background copy operation.	It is just a trivial wrapper
+ *	the background copy operation.  It is just a trivial wrapper
  *	around the CopyData routine.
  *
  * Results:
@@ -7476,31 +7847,35 @@ static void
 StopCopy(csPtr)
     CopyState *csPtr;		/* State for bg copy to stop . */
 {
+    ChannelState *inStatePtr, *outStatePtr;
     int nonBlocking;
 
     if (!csPtr) {
 	return;
     }
 
+    inStatePtr	= csPtr->readPtr->state;
+    outStatePtr	= csPtr->writePtr->state;
+
     /*
      * Restore the old blocking mode and output buffering mode.
      */
 
     nonBlocking = (csPtr->readFlags & CHANNEL_NONBLOCKING);
-    if (nonBlocking != (csPtr->readPtr->flags & CHANNEL_NONBLOCKING)) {
+    if (nonBlocking != (inStatePtr->flags & CHANNEL_NONBLOCKING)) {
 	SetBlockMode(NULL, csPtr->readPtr,
 		nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
     }
-    if (csPtr->writePtr != csPtr->writePtr) {
-	if (nonBlocking != (csPtr->writePtr->flags & CHANNEL_NONBLOCKING)) {
+    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);
 	}
     }
-    csPtr->writePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
-    csPtr->writePtr->flags |=
+    outStatePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
+    outStatePtr->flags |=
 	csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
-	    
 
     if (csPtr->cmdPtr) {
 	Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->readPtr, CopyEventProc,
@@ -7509,16 +7884,62 @@ StopCopy(csPtr)
 	    Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr,
 		    CopyEventProc, (ClientData)csPtr);
 	}
-	Tcl_DecrRefCount(csPtr->cmdPtr);
+        Tcl_DecrRefCount(csPtr->cmdPtr);
     }
-    csPtr->readPtr->csPtr = NULL;
-    csPtr->writePtr->csPtr = NULL;
+    inStatePtr->csPtr  = NULL;
+    outStatePtr->csPtr = NULL;
     ckfree((char*) 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(chanPtr, mode)
+    Channel *chanPtr;		/* Channel to modify. */
+    int mode;			/* One of TCL_MODE_BLOCKING or
+				 * TCL_MODE_NONBLOCKING. */
+{
+    int result = 0;
+    Tcl_DriverBlockModeProc *blockModeProc;
+
+    /*
+     * Start at the top of the channel stack
+     */
+
+    chanPtr = chanPtr->state->topChanPtr;
+    while (chanPtr != (Channel *) 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
@@ -7541,13 +7962,11 @@ SetBlockMode(interp, chanPtr, mode)
     int mode;			/* One of TCL_MODE_BLOCKING or
 				 * TCL_MODE_NONBLOCKING. */
 {
+    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     int result = 0;
-    if (chanPtr->typePtr->blockModeProc != NULL) {
-	result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
-		mode);
-    }
+
+    result = StackSetBlockMode(chanPtr, mode);
     if (result != 0) {
-	Tcl_SetErrno(result);
 	if (interp != (Tcl_Interp *) NULL) {
 	    Tcl_AppendResult(interp, "error setting blocking mode: ",
 		    Tcl_PosixError(interp), (char *) NULL);
@@ -7555,9 +7974,9 @@ SetBlockMode(interp, chanPtr, mode)
 	return TCL_ERROR;
     }
     if (mode == TCL_MODE_BLOCKING) {
-	chanPtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
+	statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
     } else {
-	chanPtr->flags |= CHANNEL_NONBLOCKING;
+	statePtr->flags |= CHANNEL_NONBLOCKING;
     }
     return TCL_OK;
 }
@@ -7608,23 +8027,23 @@ Tcl_GetChannelNamesEx(interp, pattern)
     Tcl_Interp *interp;		/* Interp for error reporting. */
     char *pattern;		/* pattern to filter on. */
 {
-    Channel *chanPtr;
+    ChannelState *statePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     char *name;
     Tcl_Obj *resultPtr;
 
     resultPtr = Tcl_GetObjResult(interp);
-    for (chanPtr = tsdPtr->firstChanPtr;
-	 chanPtr != NULL;
-	 chanPtr = chanPtr->nextChanPtr) {
-	if (chanPtr == (Channel *) tsdPtr->stdinChannel) {
+    for (statePtr = tsdPtr->firstCSPtr;
+	 statePtr != NULL;
+	 statePtr = statePtr->nextCSPtr) {
+        if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
 	    name = "stdin";
-	} else if (chanPtr == (Channel *) tsdPtr->stdoutChannel) {
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
 	    name = "stdout";
-	} else if (chanPtr == (Channel *) tsdPtr->stderrChannel) {
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
 	    name = "stderr";
 	} else {
-	    name = chanPtr->channelName;
+	    name = statePtr->channelName;
 	}
 	if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) &&
 		(Tcl_ListObjAppendElement(interp, resultPtr,
@@ -7634,3 +8053,462 @@ Tcl_GetChannelNamesEx(interp, pattern)
     }
     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 (interp, chan)
+     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_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+    if (hTblPtr == (Tcl_HashTable *) NULL) {
+        return 0;
+    }
+    hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
+    if (hPtr == (Tcl_HashEntry *) 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 (chan)
+    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(chanName)
+    CONST char* chanName;	/* The name of the channel to look for. */
+{
+    ChannelState *statePtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    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) == 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.
+ *
+ *----------------------------------------------------------------------
+ */
+
+char *
+Tcl_ChannelName(chanTypePtr)
+    Tcl_ChannelType *chanTypePtr;	/* Pointer to channel type. */
+{
+    return (chanTypePtr->typeName);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelVersion --
+ *
+ *	Return the of version of the channel type.
+ *
+ * Results:
+ *	TCL_CHANNEL_VERSION_2 or TCL_CHANNEL_VERSION_1.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_ChannelTypeVersion
+Tcl_ChannelVersion(chanTypePtr)
+    Tcl_ChannelType *chanTypePtr;	/* Pointer to channel type. */
+{
+    if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
+	return TCL_CHANNEL_VERSION_2;
+    } else {
+	/*
+	 * In <v2 channel versions, the version field is occupied
+	 * by the Tcl_DriverBlockModeProc
+	 */
+	return TCL_CHANNEL_VERSION_1;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelBlockModeProc --
+ *
+ *	Return the Tcl_DriverBlockModeProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverBlockModeProc *
+Tcl_ChannelBlockModeProc(chanTypePtr)
+    Tcl_ChannelType *chanTypePtr;	/* Pointer to channel type. */
+{
+    if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
+	return (chanTypePtr->blockModeProc);
+    } else {
+	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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    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(chanTypePtr)
+    Tcl_ChannelType *chanTypePtr;	/* Pointer to channel type. */
+{
+    return (chanTypePtr->flushProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelHandlerProc --
+ *
+ *	Return the Tcl_DriverHandlerProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverHandlerProc *
+Tcl_ChannelHandlerProc(chanTypePtr)
+    Tcl_ChannelType *chanTypePtr;	/* Pointer to channel type. */
+{
+    return (chanTypePtr->handlerProc);
+}