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.

10 files changed, 4478 insertions, 1912 deletions

diff --git a/generic/tcl.decls b/generic/tcl.decls
index d40d50d..47643d4 100644
--- a/generic/tcl.decls
+++ b/generic/tcl.decls
@@ -10,7 +10,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 # 
-# RCS: @(#) $Id: tcl.decls,v 1.40 2000/09/14 18:42:29 ericm Exp $
+# RCS: @(#) $Id: tcl.decls,v 1.41 2000/09/28 06:38:19 hobbs Exp $
 
 library tcl
 
@@ -987,7 +987,7 @@ declare 281 generic {
 	    int mask, Tcl_Channel prevChan)
 }
 declare 282 generic {
-    void Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan)
+    int Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
 declare 283 generic {
     Tcl_Channel Tcl_GetStackedChannel(Tcl_Channel chan)
@@ -1357,81 +1357,144 @@ declare 393 generic {
     int Tcl_CreateThread (Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc proc, \
 	    ClientData clientData, int stackSize, int flags)
 }
+
+# Introduced in 8.3.2
 declare 394 generic {
-    int Tcl_JoinThread (Tcl_ThreadId id, int* result)
+    int Tcl_ReadRaw (Tcl_Channel chan, char *dst, int bytesToRead)
 }
 declare 395 generic {
-    int Tcl_IsChannelShared (Tcl_Channel channel)
+    int Tcl_WriteRaw (Tcl_Channel chan, char *src, int srcLen)
 }
 declare 396 generic {
-    int Tcl_IsChannelRegistered (Tcl_Interp* interp, Tcl_Channel channel)
+    Tcl_Channel Tcl_GetTopChannel (Tcl_Channel chan)
 }
 declare 397 generic {
-    void Tcl_CutChannel (Tcl_Channel channel)
+    int Tcl_ChannelBuffered (Tcl_Channel chan)
 }
 declare 398 generic {
-    void Tcl_SpliceChannel (Tcl_Channel channel)
+    char * Tcl_ChannelName(Tcl_ChannelType *chanTypePtr)
 }
 declare 399 generic {
-    void Tcl_ClearChannelHandlers (Tcl_Channel channel)
+    Tcl_ChannelTypeVersion Tcl_ChannelVersion(Tcl_ChannelType *chanTypePtr)
 }
 declare 400 generic {
+    Tcl_DriverBlockModeProc * Tcl_ChannelBlockModeProc(Tcl_ChannelType \
+	    *chanTypePtr)
+}
+declare 401 generic {
+    Tcl_DriverCloseProc * Tcl_ChannelCloseProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 402 generic {
+    Tcl_DriverClose2Proc * Tcl_ChannelClose2Proc(Tcl_ChannelType *chanTypePtr)
+}
+declare 403 generic {
+    Tcl_DriverInputProc * Tcl_ChannelInputProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 404 generic {
+    Tcl_DriverOutputProc * Tcl_ChannelOutputProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 405 generic {
+    Tcl_DriverSeekProc * Tcl_ChannelSeekProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 406 generic {
+    Tcl_DriverSetOptionProc * Tcl_ChannelSetOptionProc(Tcl_ChannelType \
+	    *chanTypePtr)
+}
+declare 407 generic {
+    Tcl_DriverGetOptionProc * Tcl_ChannelGetOptionProc(Tcl_ChannelType \
+	    *chanTypePtr)
+}
+declare 408 generic {
+    Tcl_DriverWatchProc * Tcl_ChannelWatchProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 409 generic {
+    Tcl_DriverGetHandleProc * Tcl_ChannelGetHandleProc(Tcl_ChannelType \
+	    *chanTypePtr)
+}
+declare 410 generic {
+    Tcl_DriverFlushProc * Tcl_ChannelFlushProc(Tcl_ChannelType *chanTypePtr)
+}
+declare 411 generic {
+    Tcl_DriverHandlerProc * Tcl_ChannelHandlerProc(Tcl_ChannelType \
+	    *chanTypePtr)
+}
+
+# Introduced in 8.4a2
+declare 412 generic {
+    int Tcl_JoinThread (Tcl_ThreadId id, int* result)
+}
+declare 413 generic {
+    int Tcl_IsChannelShared (Tcl_Channel channel)
+}
+declare 414 generic {
+    int Tcl_IsChannelRegistered (Tcl_Interp* interp, Tcl_Channel channel)
+}
+declare 415 generic {
+    void Tcl_CutChannel (Tcl_Channel channel)
+}
+declare 416 generic {
+    void Tcl_SpliceChannel (Tcl_Channel channel)
+}
+declare 417 generic {
+    void Tcl_ClearChannelHandlers (Tcl_Channel channel)
+}
+declare 418 generic {
     int Tcl_IsChannelExisting (CONST char* channelName)
 }
 
-declare 401 generic {
+declare 419 generic {
     int Tcl_UniCharNcasecmp(CONST Tcl_UniChar *cs, CONST Tcl_UniChar *ct,\
 	    unsigned long n)
 }
-declare 402 generic {
+declare 420 generic {
     int Tcl_UniCharCaseMatch(CONST Tcl_UniChar *ustr, \
 	    CONST Tcl_UniChar *pattern, int nocase)
 }
 
-declare 403 generic {
+declare 421 generic {
     Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, \
 	    CONST char *key)
 }
 
-declare 404 generic {
+declare 422 generic {
     Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr, \
 	    CONST char *key, int *newPtr)
 }
 
-declare 405 generic {
+declare 423 generic {
     void Tcl_InitHashTableEx(Tcl_HashTable *tablePtr, int keyType, \
 	    Tcl_HashKeyType *typePtr)
 }
 
-declare 406 generic {
+declare 424 generic {
     void Tcl_InitObjHashTable(Tcl_HashTable *tablePtr)
 }
-declare 407 generic {
+declare 425 generic {
     ClientData Tcl_CommandTraceInfo(Tcl_Interp *interp, char *varName, \
 	    int flags, Tcl_CommandTraceProc *procPtr, ClientData prevClientData)
 }
-declare 408 generic {
+declare 426 generic {
     int Tcl_TraceCommand(Tcl_Interp *interp, char *varName, int flags, \
 		Tcl_CommandTraceProc *proc, ClientData clientData)
 }
-declare 409 generic {
+declare 427 generic {
     void Tcl_UntraceCommand(Tcl_Interp *interp, char *varName, int flags, \
 		Tcl_CommandTraceProc *proc, ClientData clientData)
 }
-declare 410 generic {
+declare 428 generic {
     char * Tcl_AttemptAlloc(unsigned int size)
 }
-declare 411 generic {
+declare 429 generic {
     char * Tcl_AttemptDbCkalloc(unsigned int size, char *file, int line)
 }
-declare 412 generic {
+declare 430 generic {
     char * Tcl_AttemptRealloc(char *ptr, unsigned int size)
 }
-declare 413 generic {
+declare 431 generic {
     char * Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size, char *file, 
 	int line)
 }
-declare 414 generic {
+declare 432 generic {
     int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length)
 }
 
diff --git a/generic/tcl.h b/generic/tcl.h
index 62d895f..509abce 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tcl.h,v 1.80 2000/09/20 23:09:51 jenn Exp $
+ * RCS: @(#) $Id: tcl.h,v 1.81 2000/09/28 06:38:19 hobbs Exp $
  */
 
 #ifndef _TCL
@@ -395,6 +395,7 @@ typedef struct Tcl_ThreadId_ *Tcl_ThreadId;
 typedef struct Tcl_TimerToken_ *Tcl_TimerToken;
 typedef struct Tcl_Trace_ *Tcl_Trace;
 typedef struct Tcl_Var_ *Tcl_Var;
+typedef struct Tcl_ChannelTypeVersion_ *Tcl_ChannelTypeVersion;
 
 /*
  * Definition of the interface to procedures implementing threads.
@@ -1304,6 +1305,13 @@ typedef int (Tcl_WaitForEventProc) _ANSI_ARGS_((Tcl_Time *timePtr));
 #define TCL_CLOSE2PROC	((Tcl_DriverCloseProc *)1)
 
 /*
+ * Channel version tag.  This was introduced in 8.3.2/8.4.
+ */
+
+#define TCL_CHANNEL_VERSION_1	((Tcl_ChannelTypeVersion) 0x1)
+#define TCL_CHANNEL_VERSION_2	((Tcl_ChannelTypeVersion) 0x2)
+
+/*
  * Typedefs for the various operations in a channel type:
  */
 
@@ -1330,6 +1338,10 @@ typedef void	(Tcl_DriverWatchProc) _ANSI_ARGS_((
 typedef int	(Tcl_DriverGetHandleProc) _ANSI_ARGS_((
 		    ClientData instanceData, int direction,
 		    ClientData *handlePtr));
+typedef int	(Tcl_DriverFlushProc) _ANSI_ARGS_((
+		    ClientData instanceData));
+typedef int	(Tcl_DriverHandlerProc) _ANSI_ARGS_((
+		    ClientData instanceData, int interestMask));
 
 /*
  * The following declarations either map ckalloc and ckfree to
@@ -1381,38 +1393,50 @@ typedef enum Tcl_EolTranslation {
  * One such structure exists for each type (kind) of channel.
  * It collects together in one place all the functions that are
  * part of the specific channel type.
+ *
+ * It is recommend that the Tcl_Channel* functions are used to access
+ * elements of this structure, instead of direct accessing.
  */
 
 typedef struct Tcl_ChannelType {
     char *typeName;			/* The name of the channel type in Tcl
                                          * commands. This storage is owned by
                                          * channel type. */
-    Tcl_DriverBlockModeProc *blockModeProc;
-    					/* Set blocking mode for the
-                                         * raw channel. May be NULL. */
+    Tcl_ChannelTypeVersion version;	/* Version of the channel type. */
     Tcl_DriverCloseProc *closeProc;	/* Procedure to call to close the
-                                         * channel, or TCL_CLOSE2PROC if the
-                                         * close2Proc should be used
-                                         * instead. */
+					 * channel, or TCL_CLOSE2PROC if the
+					 * close2Proc should be used
+					 * instead. */
     Tcl_DriverInputProc *inputProc;	/* Procedure to call for input
-                                         * on channel. */
+					 * on channel. */
     Tcl_DriverOutputProc *outputProc;	/* Procedure to call for output
-                                         * on channel. */
+					 * on channel. */
     Tcl_DriverSeekProc *seekProc;	/* Procedure to call to seek
-                                         * on the channel. May be NULL. */
+					 * on the channel. May be NULL. */
     Tcl_DriverSetOptionProc *setOptionProc;
-    					/* Set an option on a channel. */
+					/* Set an option on a channel. */
     Tcl_DriverGetOptionProc *getOptionProc;
-    					/* Get an option from a channel. */
+					/* Get an option from a channel. */
     Tcl_DriverWatchProc *watchProc;	/* Set up the notifier to watch
-                                         * for events on this channel. */
+					 * for events on this channel. */
     Tcl_DriverGetHandleProc *getHandleProc;
 					/* Get an OS handle from the channel
-                                         * or NULL if not supported. */
-    Tcl_DriverClose2Proc *close2Proc;   /* Procedure to call to close the
+					 * or NULL if not supported. */
+    Tcl_DriverClose2Proc *close2Proc;	/* Procedure to call to close the
 					 * channel if the device supports
 					 * closing the read & write sides
 					 * independently. */
+    Tcl_DriverBlockModeProc *blockModeProc;
+					/* Set blocking mode for the
+					 * raw channel. May be NULL. */
+    /*
+     * Only valid in TCL_CHANNEL_VERSION_2 channels
+     */
+    Tcl_DriverFlushProc *flushProc;	/* Procedure to call to flush a
+					 * channel. May be NULL. */
+    Tcl_DriverHandlerProc *handlerProc;	/* Procedure to call to handle a
+					 * channel event.  This will be passed
+					 * up the stacked channel chain. */
 } Tcl_ChannelType;
 
 /*
diff --git a/generic/tclDecls.h b/generic/tclDecls.h
index 9b2f9a8..0656d76 100644
--- a/generic/tclDecls.h
+++ b/generic/tclDecls.h
@@ -8,7 +8,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclDecls.h,v 1.41 2000/09/14 18:42:31 ericm Exp $
+ * RCS: @(#) $Id: tclDecls.h,v 1.42 2000/09/28 06:38:19 hobbs Exp $
  */
 
 #ifndef _TCLDECLS
@@ -909,7 +909,7 @@ EXTERN Tcl_Channel	Tcl_StackChannel _ANSI_ARGS_((Tcl_Interp * interp,
 				ClientData instanceData, int mask, 
 				Tcl_Channel prevChan));
 /* 282 */
-EXTERN void		Tcl_UnstackChannel _ANSI_ARGS_((Tcl_Interp * interp, 
+EXTERN int		Tcl_UnstackChannel _ANSI_ARGS_((Tcl_Interp * interp, 
 				Tcl_Channel chan));
 /* 283 */
 EXTERN Tcl_Channel	Tcl_GetStackedChannel _ANSI_ARGS_((Tcl_Channel chan));
@@ -1229,72 +1229,124 @@ EXTERN int		Tcl_CreateThread _ANSI_ARGS_((Tcl_ThreadId * idPtr,
 				ClientData clientData, int stackSize, 
 				int flags));
 /* 394 */
+EXTERN int		Tcl_ReadRaw _ANSI_ARGS_((Tcl_Channel chan, 
+				char * dst, int bytesToRead));
+/* 395 */
+EXTERN int		Tcl_WriteRaw _ANSI_ARGS_((Tcl_Channel chan, 
+				char * src, int srcLen));
+/* 396 */
+EXTERN Tcl_Channel	Tcl_GetTopChannel _ANSI_ARGS_((Tcl_Channel chan));
+/* 397 */
+EXTERN int		Tcl_ChannelBuffered _ANSI_ARGS_((Tcl_Channel chan));
+/* 398 */
+EXTERN char *		Tcl_ChannelName _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 399 */
+EXTERN Tcl_ChannelTypeVersion Tcl_ChannelVersion _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 400 */
+EXTERN Tcl_DriverBlockModeProc * Tcl_ChannelBlockModeProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 401 */
+EXTERN Tcl_DriverCloseProc * Tcl_ChannelCloseProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 402 */
+EXTERN Tcl_DriverClose2Proc * Tcl_ChannelClose2Proc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 403 */
+EXTERN Tcl_DriverInputProc * Tcl_ChannelInputProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 404 */
+EXTERN Tcl_DriverOutputProc * Tcl_ChannelOutputProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 405 */
+EXTERN Tcl_DriverSeekProc * Tcl_ChannelSeekProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 406 */
+EXTERN Tcl_DriverSetOptionProc * Tcl_ChannelSetOptionProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 407 */
+EXTERN Tcl_DriverGetOptionProc * Tcl_ChannelGetOptionProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 408 */
+EXTERN Tcl_DriverWatchProc * Tcl_ChannelWatchProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 409 */
+EXTERN Tcl_DriverGetHandleProc * Tcl_ChannelGetHandleProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 410 */
+EXTERN Tcl_DriverFlushProc * Tcl_ChannelFlushProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 411 */
+EXTERN Tcl_DriverHandlerProc * Tcl_ChannelHandlerProc _ANSI_ARGS_((
+				Tcl_ChannelType * chanTypePtr));
+/* 412 */
 EXTERN int		Tcl_JoinThread _ANSI_ARGS_((Tcl_ThreadId id, 
 				int* result));
-/* 395 */
+/* 413 */
 EXTERN int		Tcl_IsChannelShared _ANSI_ARGS_((Tcl_Channel channel));
-/* 396 */
+/* 414 */
 EXTERN int		Tcl_IsChannelRegistered _ANSI_ARGS_((
 				Tcl_Interp* interp, Tcl_Channel channel));
-/* 397 */
+/* 415 */
 EXTERN void		Tcl_CutChannel _ANSI_ARGS_((Tcl_Channel channel));
-/* 398 */
+/* 416 */
 EXTERN void		Tcl_SpliceChannel _ANSI_ARGS_((Tcl_Channel channel));
-/* 399 */
+/* 417 */
 EXTERN void		Tcl_ClearChannelHandlers _ANSI_ARGS_((
 				Tcl_Channel channel));
-/* 400 */
+/* 418 */
 EXTERN int		Tcl_IsChannelExisting _ANSI_ARGS_((
 				CONST char* channelName));
-/* 401 */
+/* 419 */
 EXTERN int		Tcl_UniCharNcasecmp _ANSI_ARGS_((
 				CONST Tcl_UniChar * cs, 
 				CONST Tcl_UniChar * ct, unsigned long n));
-/* 402 */
+/* 420 */
 EXTERN int		Tcl_UniCharCaseMatch _ANSI_ARGS_((
 				CONST Tcl_UniChar * ustr, 
 				CONST Tcl_UniChar * pattern, int nocase));
-/* 403 */
+/* 421 */
 EXTERN Tcl_HashEntry *	Tcl_FindHashEntry _ANSI_ARGS_((
 				Tcl_HashTable * tablePtr, CONST char * key));
-/* 404 */
+/* 422 */
 EXTERN Tcl_HashEntry *	Tcl_CreateHashEntry _ANSI_ARGS_((
 				Tcl_HashTable * tablePtr, CONST char * key, 
 				int * newPtr));
-/* 405 */
+/* 423 */
 EXTERN void		Tcl_InitHashTableEx _ANSI_ARGS_((
 				Tcl_HashTable * tablePtr, int keyType, 
 				Tcl_HashKeyType * typePtr));
-/* 406 */
+/* 424 */
 EXTERN void		Tcl_InitObjHashTable _ANSI_ARGS_((
 				Tcl_HashTable * tablePtr));
-/* 407 */
+/* 425 */
 EXTERN ClientData	Tcl_CommandTraceInfo _ANSI_ARGS_((
 				Tcl_Interp * interp, char * varName, 
 				int flags, Tcl_CommandTraceProc * procPtr, 
 				ClientData prevClientData));
-/* 408 */
+/* 426 */
 EXTERN int		Tcl_TraceCommand _ANSI_ARGS_((Tcl_Interp * interp, 
 				char * varName, int flags, 
 				Tcl_CommandTraceProc * proc, 
 				ClientData clientData));
-/* 409 */
+/* 427 */
 EXTERN void		Tcl_UntraceCommand _ANSI_ARGS_((Tcl_Interp * interp, 
 				char * varName, int flags, 
 				Tcl_CommandTraceProc * proc, 
 				ClientData clientData));
-/* 410 */
+/* 428 */
 EXTERN char *		Tcl_AttemptAlloc _ANSI_ARGS_((unsigned int size));
-/* 411 */
+/* 429 */
 EXTERN char *		Tcl_AttemptDbCkalloc _ANSI_ARGS_((unsigned int size, 
 				char * file, int line));
-/* 412 */
+/* 430 */
 EXTERN char *		Tcl_AttemptRealloc _ANSI_ARGS_((char * ptr, 
 				unsigned int size));
-/* 413 */
+/* 431 */
 EXTERN char *		Tcl_AttemptDbCkrealloc _ANSI_ARGS_((char * ptr, 
 				unsigned int size, char * file, int line));
-/* 414 */
+/* 432 */
 EXTERN int		Tcl_AttemptSetObjLength _ANSI_ARGS_((
 				Tcl_Obj * objPtr, int length));
 
@@ -1646,7 +1698,7 @@ typedef struct TclStubs {
     void (*tcl_GetVersion) _ANSI_ARGS_((int * major, int * minor, int * patchLevel, int * type)); /* 279 */
     void (*tcl_InitMemory) _ANSI_ARGS_((Tcl_Interp * interp)); /* 280 */
     Tcl_Channel (*tcl_StackChannel) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_ChannelType * typePtr, ClientData instanceData, int mask, Tcl_Channel prevChan)); /* 281 */
-    void (*tcl_UnstackChannel) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_Channel chan)); /* 282 */
+    int (*tcl_UnstackChannel) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_Channel chan)); /* 282 */
     Tcl_Channel (*tcl_GetStackedChannel) _ANSI_ARGS_((Tcl_Channel chan)); /* 283 */
     void *reserved284;
     void *reserved285;
@@ -1758,27 +1810,45 @@ typedef struct TclStubs {
     void (*tcl_ConditionFinalize) _ANSI_ARGS_((Tcl_Condition * condPtr)); /* 391 */
     void (*tcl_MutexFinalize) _ANSI_ARGS_((Tcl_Mutex * mutex)); /* 392 */
     int (*tcl_CreateThread) _ANSI_ARGS_((Tcl_ThreadId * idPtr, Tcl_ThreadCreateProc proc, ClientData clientData, int stackSize, int flags)); /* 393 */
-    int (*tcl_JoinThread) _ANSI_ARGS_((Tcl_ThreadId id, int* result)); /* 394 */
-    int (*tcl_IsChannelShared) _ANSI_ARGS_((Tcl_Channel channel)); /* 395 */
-    int (*tcl_IsChannelRegistered) _ANSI_ARGS_((Tcl_Interp* interp, Tcl_Channel channel)); /* 396 */
-    void (*tcl_CutChannel) _ANSI_ARGS_((Tcl_Channel channel)); /* 397 */
-    void (*tcl_SpliceChannel) _ANSI_ARGS_((Tcl_Channel channel)); /* 398 */
-    void (*tcl_ClearChannelHandlers) _ANSI_ARGS_((Tcl_Channel channel)); /* 399 */
-    int (*tcl_IsChannelExisting) _ANSI_ARGS_((CONST char* channelName)); /* 400 */
-    int (*tcl_UniCharNcasecmp) _ANSI_ARGS_((CONST Tcl_UniChar * cs, CONST Tcl_UniChar * ct, unsigned long n)); /* 401 */
-    int (*tcl_UniCharCaseMatch) _ANSI_ARGS_((CONST Tcl_UniChar * ustr, CONST Tcl_UniChar * pattern, int nocase)); /* 402 */
-    Tcl_HashEntry * (*tcl_FindHashEntry) _ANSI_ARGS_((Tcl_HashTable * tablePtr, CONST char * key)); /* 403 */
-    Tcl_HashEntry * (*tcl_CreateHashEntry) _ANSI_ARGS_((Tcl_HashTable * tablePtr, CONST char * key, int * newPtr)); /* 404 */
-    void (*tcl_InitHashTableEx) _ANSI_ARGS_((Tcl_HashTable * tablePtr, int keyType, Tcl_HashKeyType * typePtr)); /* 405 */
-    void (*tcl_InitObjHashTable) _ANSI_ARGS_((Tcl_HashTable * tablePtr)); /* 406 */
-    ClientData (*tcl_CommandTraceInfo) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * procPtr, ClientData prevClientData)); /* 407 */
-    int (*tcl_TraceCommand) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * proc, ClientData clientData)); /* 408 */
-    void (*tcl_UntraceCommand) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * proc, ClientData clientData)); /* 409 */
-    char * (*tcl_AttemptAlloc) _ANSI_ARGS_((unsigned int size)); /* 410 */
-    char * (*tcl_AttemptDbCkalloc) _ANSI_ARGS_((unsigned int size, char * file, int line)); /* 411 */
-    char * (*tcl_AttemptRealloc) _ANSI_ARGS_((char * ptr, unsigned int size)); /* 412 */
-    char * (*tcl_AttemptDbCkrealloc) _ANSI_ARGS_((char * ptr, unsigned int size, char * file, int line)); /* 413 */
-    int (*tcl_AttemptSetObjLength) _ANSI_ARGS_((Tcl_Obj * objPtr, int length)); /* 414 */
+    int (*tcl_ReadRaw) _ANSI_ARGS_((Tcl_Channel chan, char * dst, int bytesToRead)); /* 394 */
+    int (*tcl_WriteRaw) _ANSI_ARGS_((Tcl_Channel chan, char * src, int srcLen)); /* 395 */
+    Tcl_Channel (*tcl_GetTopChannel) _ANSI_ARGS_((Tcl_Channel chan)); /* 396 */
+    int (*tcl_ChannelBuffered) _ANSI_ARGS_((Tcl_Channel chan)); /* 397 */
+    char * (*tcl_ChannelName) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 398 */
+    Tcl_ChannelTypeVersion (*tcl_ChannelVersion) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 399 */
+    Tcl_DriverBlockModeProc * (*tcl_ChannelBlockModeProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 400 */
+    Tcl_DriverCloseProc * (*tcl_ChannelCloseProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 401 */
+    Tcl_DriverClose2Proc * (*tcl_ChannelClose2Proc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 402 */
+    Tcl_DriverInputProc * (*tcl_ChannelInputProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 403 */
+    Tcl_DriverOutputProc * (*tcl_ChannelOutputProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 404 */
+    Tcl_DriverSeekProc * (*tcl_ChannelSeekProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 405 */
+    Tcl_DriverSetOptionProc * (*tcl_ChannelSetOptionProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 406 */
+    Tcl_DriverGetOptionProc * (*tcl_ChannelGetOptionProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 407 */
+    Tcl_DriverWatchProc * (*tcl_ChannelWatchProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 408 */
+    Tcl_DriverGetHandleProc * (*tcl_ChannelGetHandleProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 409 */
+    Tcl_DriverFlushProc * (*tcl_ChannelFlushProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 410 */
+    Tcl_DriverHandlerProc * (*tcl_ChannelHandlerProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 411 */
+    int (*tcl_JoinThread) _ANSI_ARGS_((Tcl_ThreadId id, int* result)); /* 412 */
+    int (*tcl_IsChannelShared) _ANSI_ARGS_((Tcl_Channel channel)); /* 413 */
+    int (*tcl_IsChannelRegistered) _ANSI_ARGS_((Tcl_Interp* interp, Tcl_Channel channel)); /* 414 */
+    void (*tcl_CutChannel) _ANSI_ARGS_((Tcl_Channel channel)); /* 415 */
+    void (*tcl_SpliceChannel) _ANSI_ARGS_((Tcl_Channel channel)); /* 416 */
+    void (*tcl_ClearChannelHandlers) _ANSI_ARGS_((Tcl_Channel channel)); /* 417 */
+    int (*tcl_IsChannelExisting) _ANSI_ARGS_((CONST char* channelName)); /* 418 */
+    int (*tcl_UniCharNcasecmp) _ANSI_ARGS_((CONST Tcl_UniChar * cs, CONST Tcl_UniChar * ct, unsigned long n)); /* 419 */
+    int (*tcl_UniCharCaseMatch) _ANSI_ARGS_((CONST Tcl_UniChar * ustr, CONST Tcl_UniChar * pattern, int nocase)); /* 420 */
+    Tcl_HashEntry * (*tcl_FindHashEntry) _ANSI_ARGS_((Tcl_HashTable * tablePtr, CONST char * key)); /* 421 */
+    Tcl_HashEntry * (*tcl_CreateHashEntry) _ANSI_ARGS_((Tcl_HashTable * tablePtr, CONST char * key, int * newPtr)); /* 422 */
+    void (*tcl_InitHashTableEx) _ANSI_ARGS_((Tcl_HashTable * tablePtr, int keyType, Tcl_HashKeyType * typePtr)); /* 423 */
+    void (*tcl_InitObjHashTable) _ANSI_ARGS_((Tcl_HashTable * tablePtr)); /* 424 */
+    ClientData (*tcl_CommandTraceInfo) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * procPtr, ClientData prevClientData)); /* 425 */
+    int (*tcl_TraceCommand) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * proc, ClientData clientData)); /* 426 */
+    void (*tcl_UntraceCommand) _ANSI_ARGS_((Tcl_Interp * interp, char * varName, int flags, Tcl_CommandTraceProc * proc, ClientData clientData)); /* 427 */
+    char * (*tcl_AttemptAlloc) _ANSI_ARGS_((unsigned int size)); /* 428 */
+    char * (*tcl_AttemptDbCkalloc) _ANSI_ARGS_((unsigned int size, char * file, int line)); /* 429 */
+    char * (*tcl_AttemptRealloc) _ANSI_ARGS_((char * ptr, unsigned int size)); /* 430 */
+    char * (*tcl_AttemptDbCkrealloc) _ANSI_ARGS_((char * ptr, unsigned int size, char * file, int line)); /* 431 */
+    int (*tcl_AttemptSetObjLength) _ANSI_ARGS_((Tcl_Obj * objPtr, int length)); /* 432 */
 } TclStubs;
 
 #ifdef __cplusplus
@@ -3400,89 +3470,161 @@ extern TclStubs *tclStubsPtr;
 #define Tcl_CreateThread \
 	(tclStubsPtr->tcl_CreateThread) /* 393 */
 #endif
+#ifndef Tcl_ReadRaw
+#define Tcl_ReadRaw \
+	(tclStubsPtr->tcl_ReadRaw) /* 394 */
+#endif
+#ifndef Tcl_WriteRaw
+#define Tcl_WriteRaw \
+	(tclStubsPtr->tcl_WriteRaw) /* 395 */
+#endif
+#ifndef Tcl_GetTopChannel
+#define Tcl_GetTopChannel \
+	(tclStubsPtr->tcl_GetTopChannel) /* 396 */
+#endif
+#ifndef Tcl_ChannelBuffered
+#define Tcl_ChannelBuffered \
+	(tclStubsPtr->tcl_ChannelBuffered) /* 397 */
+#endif
+#ifndef Tcl_ChannelName
+#define Tcl_ChannelName \
+	(tclStubsPtr->tcl_ChannelName) /* 398 */
+#endif
+#ifndef Tcl_ChannelVersion
+#define Tcl_ChannelVersion \
+	(tclStubsPtr->tcl_ChannelVersion) /* 399 */
+#endif
+#ifndef Tcl_ChannelBlockModeProc
+#define Tcl_ChannelBlockModeProc \
+	(tclStubsPtr->tcl_ChannelBlockModeProc) /* 400 */
+#endif
+#ifndef Tcl_ChannelCloseProc
+#define Tcl_ChannelCloseProc \
+	(tclStubsPtr->tcl_ChannelCloseProc) /* 401 */
+#endif
+#ifndef Tcl_ChannelClose2Proc
+#define Tcl_ChannelClose2Proc \
+	(tclStubsPtr->tcl_ChannelClose2Proc) /* 402 */
+#endif
+#ifndef Tcl_ChannelInputProc
+#define Tcl_ChannelInputProc \
+	(tclStubsPtr->tcl_ChannelInputProc) /* 403 */
+#endif
+#ifndef Tcl_ChannelOutputProc
+#define Tcl_ChannelOutputProc \
+	(tclStubsPtr->tcl_ChannelOutputProc) /* 404 */
+#endif
+#ifndef Tcl_ChannelSeekProc
+#define Tcl_ChannelSeekProc \
+	(tclStubsPtr->tcl_ChannelSeekProc) /* 405 */
+#endif
+#ifndef Tcl_ChannelSetOptionProc
+#define Tcl_ChannelSetOptionProc \
+	(tclStubsPtr->tcl_ChannelSetOptionProc) /* 406 */
+#endif
+#ifndef Tcl_ChannelGetOptionProc
+#define Tcl_ChannelGetOptionProc \
+	(tclStubsPtr->tcl_ChannelGetOptionProc) /* 407 */
+#endif
+#ifndef Tcl_ChannelWatchProc
+#define Tcl_ChannelWatchProc \
+	(tclStubsPtr->tcl_ChannelWatchProc) /* 408 */
+#endif
+#ifndef Tcl_ChannelGetHandleProc
+#define Tcl_ChannelGetHandleProc \
+	(tclStubsPtr->tcl_ChannelGetHandleProc) /* 409 */
+#endif
+#ifndef Tcl_ChannelFlushProc
+#define Tcl_ChannelFlushProc \
+	(tclStubsPtr->tcl_ChannelFlushProc) /* 410 */
+#endif
+#ifndef Tcl_ChannelHandlerProc
+#define Tcl_ChannelHandlerProc \
+	(tclStubsPtr->tcl_ChannelHandlerProc) /* 411 */
+#endif
 #ifndef Tcl_JoinThread
 #define Tcl_JoinThread \
-	(tclStubsPtr->tcl_JoinThread) /* 394 */
+	(tclStubsPtr->tcl_JoinThread) /* 412 */
 #endif
 #ifndef Tcl_IsChannelShared
 #define Tcl_IsChannelShared \
-	(tclStubsPtr->tcl_IsChannelShared) /* 395 */
+	(tclStubsPtr->tcl_IsChannelShared) /* 413 */
 #endif
 #ifndef Tcl_IsChannelRegistered
 #define Tcl_IsChannelRegistered \
-	(tclStubsPtr->tcl_IsChannelRegistered) /* 396 */
+	(tclStubsPtr->tcl_IsChannelRegistered) /* 414 */
 #endif
 #ifndef Tcl_CutChannel
 #define Tcl_CutChannel \
-	(tclStubsPtr->tcl_CutChannel) /* 397 */
+	(tclStubsPtr->tcl_CutChannel) /* 415 */
 #endif
 #ifndef Tcl_SpliceChannel
 #define Tcl_SpliceChannel \
-	(tclStubsPtr->tcl_SpliceChannel) /* 398 */
+	(tclStubsPtr->tcl_SpliceChannel) /* 416 */
 #endif
 #ifndef Tcl_ClearChannelHandlers
 #define Tcl_ClearChannelHandlers \
-	(tclStubsPtr->tcl_ClearChannelHandlers) /* 399 */
+	(tclStubsPtr->tcl_ClearChannelHandlers) /* 417 */
 #endif
 #ifndef Tcl_IsChannelExisting
 #define Tcl_IsChannelExisting \
-	(tclStubsPtr->tcl_IsChannelExisting) /* 400 */
+	(tclStubsPtr->tcl_IsChannelExisting) /* 418 */
 #endif
 #ifndef Tcl_UniCharNcasecmp
 #define Tcl_UniCharNcasecmp \
-	(tclStubsPtr->tcl_UniCharNcasecmp) /* 401 */
+	(tclStubsPtr->tcl_UniCharNcasecmp) /* 419 */
 #endif
 #ifndef Tcl_UniCharCaseMatch
 #define Tcl_UniCharCaseMatch \
-	(tclStubsPtr->tcl_UniCharCaseMatch) /* 402 */
+	(tclStubsPtr->tcl_UniCharCaseMatch) /* 420 */
 #endif
 #ifndef Tcl_FindHashEntry
 #define Tcl_FindHashEntry \
-	(tclStubsPtr->tcl_FindHashEntry) /* 403 */
+	(tclStubsPtr->tcl_FindHashEntry) /* 421 */
 #endif
 #ifndef Tcl_CreateHashEntry
 #define Tcl_CreateHashEntry \
-	(tclStubsPtr->tcl_CreateHashEntry) /* 404 */
+	(tclStubsPtr->tcl_CreateHashEntry) /* 422 */
 #endif
 #ifndef Tcl_InitHashTableEx
 #define Tcl_InitHashTableEx \
-	(tclStubsPtr->tcl_InitHashTableEx) /* 405 */
+	(tclStubsPtr->tcl_InitHashTableEx) /* 423 */
 #endif
 #ifndef Tcl_InitObjHashTable
 #define Tcl_InitObjHashTable \
-	(tclStubsPtr->tcl_InitObjHashTable) /* 406 */
+	(tclStubsPtr->tcl_InitObjHashTable) /* 424 */
 #endif
 #ifndef Tcl_CommandTraceInfo
 #define Tcl_CommandTraceInfo \
-	(tclStubsPtr->tcl_CommandTraceInfo) /* 407 */
+	(tclStubsPtr->tcl_CommandTraceInfo) /* 425 */
 #endif
 #ifndef Tcl_TraceCommand
 #define Tcl_TraceCommand \
-	(tclStubsPtr->tcl_TraceCommand) /* 408 */
+	(tclStubsPtr->tcl_TraceCommand) /* 426 */
 #endif
 #ifndef Tcl_UntraceCommand
 #define Tcl_UntraceCommand \
-	(tclStubsPtr->tcl_UntraceCommand) /* 409 */
+	(tclStubsPtr->tcl_UntraceCommand) /* 427 */
 #endif
 #ifndef Tcl_AttemptAlloc
 #define Tcl_AttemptAlloc \
-	(tclStubsPtr->tcl_AttemptAlloc) /* 410 */
+	(tclStubsPtr->tcl_AttemptAlloc) /* 428 */
 #endif
 #ifndef Tcl_AttemptDbCkalloc
 #define Tcl_AttemptDbCkalloc \
-	(tclStubsPtr->tcl_AttemptDbCkalloc) /* 411 */
+	(tclStubsPtr->tcl_AttemptDbCkalloc) /* 429 */
 #endif
 #ifndef Tcl_AttemptRealloc
 #define Tcl_AttemptRealloc \
-	(tclStubsPtr->tcl_AttemptRealloc) /* 412 */
+	(tclStubsPtr->tcl_AttemptRealloc) /* 430 */
 #endif
 #ifndef Tcl_AttemptDbCkrealloc
 #define Tcl_AttemptDbCkrealloc \
-	(tclStubsPtr->tcl_AttemptDbCkrealloc) /* 413 */
+	(tclStubsPtr->tcl_AttemptDbCkrealloc) /* 431 */
 #endif
 #ifndef Tcl_AttemptSetObjLength
 #define Tcl_AttemptSetObjLength \
-	(tclStubsPtr->tcl_AttemptSetObjLength) /* 414 */
+	(tclStubsPtr->tcl_AttemptSetObjLength) /* 432 */
 #endif
 
 #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
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);
+}
diff --git a/generic/tclIO.h b/generic/tclIO.h
index b75aa5b..b232cba 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -1,17 +1,16 @@
 /* 
  * tclIO.h --
  *
- *	This file provides the header information (those that are the same on
+ *	This file provides the generic portions (those that are the same on
  *	all platforms and for all channel types) of Tcl's IO facilities.
- *	This is used by tclIO.c and tclTest.c.
  *
+ * 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.h,v 1.1 2000/05/19 21:30:17 hobbs Exp $
+ * RCS: @(#) $Id: tclIO.h,v 1.2 2000/09/28 06:38:21 hobbs Exp $
  */
 
 /*
@@ -29,7 +28,7 @@
 #   define EAGAIN EWOULDBLOCK
 #endif
 #if ((!defined(EAGAIN)) && (!defined(EWOULDBLOCK)))
-    error one of EWOULDBLOCK or EAGAIN must be defined
+error one of EWOULDBLOCK or EAGAIN must be defined
 #endif
 
 /*
@@ -96,7 +95,7 @@ typedef struct ChannelBuffer {
 typedef struct CloseCallback {
     Tcl_CloseProc *proc;		/* The procedure to call. */
     ClientData clientData;		/* Arbitrary one-word data to pass
-                                         * to the callback. */
+					 * to the callback. */
     struct CloseCallback *nextPtr;	/* For chaining close callbacks. */
 } CloseCallback;
 
@@ -108,15 +107,15 @@ typedef struct CloseCallback {
 
 typedef struct EventScriptRecord {
     struct Channel *chanPtr;	/* The channel for which this script is
-                                 * registered. This is used only when an
-                                 * error occurs during evaluation of the
-                                 * script, to delete the handler. */
+				 * registered. This is used only when an
+				 * error occurs during evaluation of the
+				 * script, to delete the handler. */
     Tcl_Obj *scriptPtr;		/* Script to invoke. */
     Tcl_Interp *interp;		/* In what interpreter to invoke script? */
     int mask;			/* Events must overlap current mask for the
-                                 * stored script to be invoked. */
+				 * stored script to be invoked. */
     struct EventScriptRecord *nextPtr;
-    				/* Next in chain of records. */
+				/* Next in chain of records. */
 } EventScriptRecord;
 
 /*
@@ -129,11 +128,41 @@ typedef struct EventScriptRecord {
  */
 
 typedef struct Channel {
+    struct ChannelState *state; /* Split out state information */
+
+    ClientData instanceData;	/* Instance-specific data provided by
+				 * creator of channel. */
+    Tcl_ChannelType *typePtr;	/* Pointer to channel type structure. */
+
+    struct Channel *downChanPtr;/* Refers to channel this one was stacked
+				 * upon.  This reference is NULL for normal
+				 * channels.  See Tcl_StackChannel. */
+    struct Channel *upChanPtr;	/* Refers to the channel above stacked this
+				 * one. NULL for the top most channel. */
+
+    /*
+     * Intermediate buffers to hold pre-read data for consumption by a
+     * newly stacked transformation. See 'Tcl_StackChannel'.
+     */
+    ChannelBuffer *inQueueHead;	/* Points at first buffer in input queue. */
+    ChannelBuffer *inQueueTail;	/* Points at last buffer in input queue. */
+} Channel;
+
+/*
+ * struct ChannelState:
+ *
+ * One of these structures is allocated for each open channel. It contains data
+ * specific to the channel but which belongs to the generic part of the Tcl
+ * channel mechanism, and it points at an instance specific (and type
+ * specific) * instance data, and at a channel type structure.
+ */
+
+typedef struct ChannelState {
     char *channelName;		/* The name of the channel instance in Tcl
-                                 * commands. Storage is owned by the generic IO
-                                 * code,  is dynamically allocated. */
+				 * commands. Storage is owned by the generic IO
+				 * code, is dynamically allocated. */
     int	flags;			/* ORed combination of the flags defined
-                                 * below. */
+				 * below. */
     Tcl_Encoding encoding;	/* Encoding to apply when reading or writing
 				 * data on this channel.  NULL means no
 				 * encoding is applied to data. */
@@ -155,26 +184,23 @@ typedef struct Channel {
 				 * TCL_ENCODING_END when EOF is seen. */
     Tcl_EolTranslation inputTranslation;
 				/* What translation to apply for end of line
-                                 * sequences on input? */    
+				 * sequences on input? */    
     Tcl_EolTranslation outputTranslation;
-    				/* What translation to use for generating
-                                 * end of line sequences in output? */
+				/* What translation to use for generating
+				 * end of line sequences in output? */
     int inEofChar;		/* If nonzero, use this as a signal of EOF
-                                 * on input. */
+				 * on input. */
     int outEofChar;             /* If nonzero, append this to the channel
-                                 * when it is closed if it is open for
-                                 * writing. */
+				 * when it is closed if it is open for
+				 * writing. */
     int unreportedError;	/* Non-zero if an error report was deferred
-                                 * because it happened in the background. The
-                                 * value is the POSIX error code. */
-    ClientData instanceData;	/* Instance-specific data provided by
-				 * creator of channel. */
-
-    Tcl_ChannelType *typePtr;	/* Pointer to channel type structure. */
+				 * because it happened in the background. The
+				 * value is the POSIX error code. */
     int refCount;		/* How many interpreters hold references to
-                                 * this IO channel? */
+				 * this IO channel? */
+
     CloseCallback *closeCbPtr;	/* Callbacks registered to be called when the
-                                 * channel is closed. */
+				 * channel is closed. */
     char *outputStage;		/* Temporary staging buffer used when
 				 * translating EOL before converting from
 				 * UTF-8 to external form. */
@@ -183,28 +209,31 @@ typedef struct Channel {
     ChannelBuffer *outQueueTail;/* Points at last buffer in output queue. */
 
     ChannelBuffer *saveInBufPtr;/* Buffer saved for input queue - eliminates
-                                 * need to allocate a new buffer for "gets"
-                                 * that crosses buffer boundaries. */
+				 * need to allocate a new buffer for "gets"
+				 * that crosses buffer boundaries. */
     ChannelBuffer *inQueueHead;	/* Points at first buffer in input queue. */
     ChannelBuffer *inQueueTail;	/* Points at last buffer in input queue. */
 
     struct ChannelHandler *chPtr;/* List of channel handlers registered
-                                  * for this channel. */
+				  * for this channel. */
     int interestMask;		/* Mask of all events this channel has
-                                 * handlers for. */
-    struct Channel *nextChanPtr;/* Next in list of channels currently open. */
+				 * handlers for. */
     EventScriptRecord *scriptRecordPtr;
-    				/* Chain of all scripts registered for
-                                 * event handlers ("fileevent") on this
-                                 * channel. */
+				/* Chain of all scripts registered for
+				 * event handlers ("fileevent") on this
+				 * channel. */
+
     int bufSize;		/* What size buffers to allocate? */
     Tcl_TimerToken timer;	/* Handle to wakeup timer for this channel. */
     CopyState *csPtr;		/* State of background copy, or NULL. */
-    struct Channel* supercedes; /* Refers to channel this one was stacked upon.
-				   This reference is NULL for normal channels.
-				   See Tcl_StackChannel. */
-
-} Channel;
+    Channel *topChanPtr;	/* Refers to topmost channel in a stack.
+				 * Never NULL. */
+    Channel *bottomChanPtr;	/* Refers to bottommost channel in a stack.
+				 * This channel can be relied on to live as
+				 * long as the channel state. Never NULL. */
+    struct ChannelState *nextCSPtr;
+				/* Next in list of channels currently open. */
+} ChannelState;
     
 /*
  * Values for the flags field in Channel. Any ORed combination of the
@@ -237,10 +266,10 @@ typedef struct Channel {
 					 * we saw the input eofChar. This bit
                                          * prevents clearing of the EOF bit
                                          * before every input operation. */
-#define CHANNEL_BLOCKED	(1<<11)	/* EWOULDBLOCK or EAGAIN occurred
+#define CHANNEL_BLOCKED		(1<<11)	/* EWOULDBLOCK or EAGAIN occurred
 					 * on this channel. This bit is
-                                         * cleared before every input or
-                                         * output operation. */
+					 * cleared before every input or
+					 * output operation. */
 #define INPUT_SAW_CR		(1<<12)	/* Channel is in CRLF eol input
 					 * translation mode and the last
                                          * byte seen was a "\r". */
@@ -263,6 +292,8 @@ typedef struct Channel {
 					 * When set, file events will not be
 					 * delivered for buffered data until
 					 * the state of the channel changes. */
+#define CHANNEL_RAW_MODE	(1<<16)	/* When set, notes that the Raw API is
+					 * being used. */
 
 /*
  * For each channel handler registered in a call to Tcl_CreateChannelHandler,
@@ -301,8 +332,8 @@ typedef struct NextChannelHandler {
     ChannelHandler *nextHandlerPtr;	/* The next handler to be invoked in
                                          * this invocation. */
     struct NextChannelHandler *nestedHandlerPtr;
-					/* Next nested invocation of
-                                         * ChannelHandlerEventProc. */
+    /* Next nested invocation of
+     * ChannelHandlerEventProc. */
 } NextChannelHandler;
 
 
diff --git a/generic/tclIOGT.c b/generic/tclIOGT.c
new file mode 100644
index 0000000..70de14f
--- /dev/null
+++ b/generic/tclIOGT.c
@@ -0,0 +1,1359 @@
+/*
+ * tclIOGT.c --
+ *
+ *	Implements a generic transformation exposing the underlying API
+ *	at the script level.  Contributed by Andreas Kupries.
+ *
+ * Copyright (c) 2000 Ajuba Solutions
+ * Copyright (c) 1999-2000 Andreas Kupries (a.kupries@westend.com)
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * CVS: $Id: tclIOGT.c,v 1.2 2000/09/28 06:38:21 hobbs Exp $
+ */
+
+#include "tclInt.h"
+#include "tclPort.h"
+#include "tclIO.h"
+
+
+/*
+ * Forward declarations of internal procedures.
+ * First the driver procedures of the transformation.
+ */
+
+static int		TransformBlockModeProc _ANSI_ARGS_ ((
+				ClientData instanceData, int mode));
+static int		TransformCloseProc _ANSI_ARGS_ ((
+				ClientData instanceData, Tcl_Interp* interp));
+static int		TransformInputProc _ANSI_ARGS_ ((
+				ClientData instanceData,
+				char* buf, int toRead, int* errorCodePtr));
+static int		TransformOutputProc _ANSI_ARGS_ ((
+				ClientData instanceData,
+				char*  buf, int toWrite, int* errorCodePtr));
+static int		TransformSeekProc _ANSI_ARGS_ ((
+				ClientData instanceData, long offset,
+				int mode, int* errorCodePtr));
+static int		TransformSetOptionProc _ANSI_ARGS_((
+				ClientData instanceData, Tcl_Interp *interp,
+				char *optionName, char *value));
+static int		TransformGetOptionProc _ANSI_ARGS_((
+				ClientData instanceData, Tcl_Interp *interp,
+				char *optionName, Tcl_DString *dsPtr));
+static void		TransformWatchProc _ANSI_ARGS_ ((
+				ClientData instanceData, int mask));
+static int		TransformGetFileHandleProc _ANSI_ARGS_ ((
+				ClientData instanceData, int direction,
+				ClientData* handlePtr));
+static int		TransformNotifyProc _ANSI_ARGS_ ((
+				ClientData instanceData, int mask));
+
+/*
+ * Forward declarations of internal procedures.
+ * Secondly the procedures for handling and generating fileeevents.
+ */
+
+static void		TransformChannelHandlerTimer _ANSI_ARGS_ ((
+				ClientData clientData));
+
+/*
+ * Forward declarations of internal procedures.
+ * Third, helper procedures encapsulating essential tasks.
+ */
+
+typedef struct TransformChannelData TransformChannelData;
+
+static int		ExecuteCallback _ANSI_ARGS_ ((
+				TransformChannelData* ctrl, Tcl_Interp* interp,
+				unsigned char* op, unsigned char* buf,
+				int bufLen, int transmit, int preserve));
+
+/*
+ * Action codes to give to 'ExecuteCallback' (argument 'transmit')
+ * confering to the procedure what to do with the result of the script
+ * it calls.
+ */
+
+#define TRANSMIT_DONT  (0) /* No transfer to do */
+#define TRANSMIT_DOWN  (1) /* Transfer to the underlying channel */
+#define TRANSMIT_SELF  (2) /* Transfer into our channel. */
+#define TRANSMIT_IBUF  (3) /* Transfer to internal input buffer */
+#define TRANSMIT_NUM   (4) /* Transfer number to 'maxRead' */
+
+/*
+ * Codes for 'preserve' of 'ExecuteCallback'
+ */
+
+#define P_PRESERVE    (1)
+#define P_NO_PRESERVE (0)
+
+/*
+ * Strings for the action codes delivered to the script implementing
+ * a transformation. Argument 'op' of 'ExecuteCallback'.
+ */
+
+#define A_CREATE_WRITE	(UCHARP ("create/write"))
+#define A_DELETE_WRITE	(UCHARP ("delete/write"))
+#define A_FLUSH_WRITE	(UCHARP ("flush/write"))
+#define A_WRITE		(UCHARP ("write"))
+
+#define A_CREATE_READ	(UCHARP ("create/read"))
+#define A_DELETE_READ	(UCHARP ("delete/read"))
+#define A_FLUSH_READ	(UCHARP ("flush/read"))
+#define A_READ		(UCHARP ("read"))
+
+#define A_QUERY_MAXREAD (UCHARP ("query/maxRead"))
+#define A_CLEAR_READ	(UCHARP ("clear/read"))
+
+/*
+ * Management of a simple buffer.
+ */
+
+typedef struct ResultBuffer ResultBuffer;
+
+static void		ResultClear  _ANSI_ARGS_ ((ResultBuffer* r));
+static void		ResultInit   _ANSI_ARGS_ ((ResultBuffer* r));
+static int		ResultLength _ANSI_ARGS_ ((ResultBuffer* r));
+static int		ResultCopy   _ANSI_ARGS_ ((ResultBuffer* r,
+				unsigned char* buf, int toRead));
+static void		ResultAdd    _ANSI_ARGS_ ((ResultBuffer* r,
+				unsigned char* buf, int toWrite));
+
+/*
+ * This structure describes the channel type structure for tcl based
+ * transformations.
+ */
+
+static Tcl_ChannelType transformChannelType = {
+    "transform",			/* Type name. */
+    TCL_CHANNEL_VERSION_2,
+    TransformCloseProc,			/* Close proc. */
+    TransformInputProc,			/* Input proc. */
+    TransformOutputProc,		/* Output proc. */
+    TransformSeekProc,			/* Seek proc. */
+    TransformSetOptionProc,		/* Set option proc. */
+    TransformGetOptionProc,		/* Get option proc. */
+    TransformWatchProc,			/* Initialize notifier. */
+    TransformGetFileHandleProc,		/* Get OS handles out of channel. */
+    NULL,				/* close2proc */
+    TransformBlockModeProc,		/* Set blocking/nonblocking mode.*/
+    NULL,				/* Flush proc. */
+    TransformNotifyProc,                /* Handling of events bubbling up */
+};
+
+/*
+ * Possible values for 'flags' field in control structure, see below.
+ */
+
+#define CHANNEL_ASYNC		(1<<0) /* non-blocking mode */
+
+/*
+ * Definition of the structure containing the information about the
+ * internal input buffer.
+ */
+
+struct ResultBuffer {
+    unsigned char* buf;       /* Reference to the buffer area */
+    int            allocated; /* Allocated size of the buffer area */
+    int            used;      /* Number of bytes in the buffer, <= allocated */
+};
+
+/*
+ * Additional bytes to allocate during buffer expansion
+ */
+
+#define INCREMENT (512)
+
+/*
+ * Number of milliseconds to wait before firing an event to flush
+ * out information waiting in buffers (fileevent support).
+ */
+
+#define DELAY (5)
+
+/*
+ * Convenience macro to make some casts easier to use.
+ */
+
+#define UCHARP(x) ((unsigned char*) (x))
+#define NO_INTERP ((Tcl_Interp*) NULL)
+
+/*
+ * Definition of a structure used by all transformations generated here to
+ * maintain their local state.
+ */
+
+struct TransformChannelData {
+
+    /*
+     * General section. Data to integrate the transformation into the channel
+     * system.
+     */
+
+    Tcl_Channel self;     /* Our own Channel handle */
+    int readIsFlushed;    /* Flag to note wether in.flushProc was called or not
+			   */
+    int flags;            /* Currently CHANNEL_ASYNC or zero */
+    int watchMask;        /* Current watch/event/interest mask */
+    int mode;             /* mode of parent channel, OR'ed combination of
+			   * TCL_READABLE, TCL_WRITABLE */
+    Tcl_TimerToken timer; /* Timer for automatic flushing of information
+			   * sitting in an internal buffer. Required for full
+			   * fileevent support */
+    /*
+     * Transformation specific data.
+     */
+
+    int maxRead;            /* Maximum allowed number of bytes to read, as
+			     * given to us by the tcl script implementing the
+			     * transformation. */
+    Tcl_Interp*    interp;  /* Reference to the interpreter which created the
+			     * transformation. Used to execute the code
+			     * below. */
+    Tcl_Obj*       command; /* Tcl code to execute for a buffer */
+    ResultBuffer   result;  /* Internal buffer used to store the result of a
+			     * transformation of incoming data. Additionally
+			     * serves as buffer of all data not yet consumed by
+			     * the reader. */
+};
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclChannelTransform --
+ *
+ *	Implements the Tcl "testchannel transform" debugging command.
+ *	This is part of the testing environment.  This sets up a tcl
+ *	script (cmdObjPtr) to be used as a transform on the channel.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+int
+TclChannelTransform(interp, chan, cmdObjPtr)
+    Tcl_Interp	*interp;	/* Interpreter for result. */
+    Tcl_Channel chan;		/* Channel to transform. */
+    Tcl_Obj	*cmdObjPtr;	/* Script to use for transform. */
+{
+    Channel			*chanPtr;	/* The actual channel. */
+    ChannelState		*statePtr;	/* state info for channel */
+    int				mode;		/* rw mode of the channel */
+    TransformChannelData	*dataPtr;
+    int				res;
+    Tcl_DString			ds;
+
+    if (chan == (Tcl_Channel) NULL) {
+	return TCL_ERROR;
+    }
+    chanPtr	= (Channel *) chan;
+    statePtr	= chanPtr->state;
+    chanPtr	= statePtr->topChanPtr;
+    chan	= (Tcl_Channel) chanPtr;
+    mode	= (statePtr->flags & (TCL_READABLE|TCL_WRITABLE));
+
+    /*
+     * Now initialize the transformation state and stack it upon the
+     * specified channel. One of the necessary things to do is to
+     * retrieve the blocking regime of the underlying channel and to
+     * use the same for us too.
+     */
+
+    dataPtr = (TransformChannelData*) ckalloc(sizeof(TransformChannelData));
+
+    Tcl_DStringInit (&ds);
+    Tcl_GetChannelOption(interp, chan, "-blocking", &ds);
+
+    dataPtr->readIsFlushed = 0;
+    dataPtr->flags	= 0;
+
+    if (ds.string[0] == '0') {
+	dataPtr->flags |= CHANNEL_ASYNC;
+    }
+
+    Tcl_DStringFree (&ds);
+
+    dataPtr->self	= chan;
+    dataPtr->watchMask	= 0;
+    dataPtr->mode	= mode;
+    dataPtr->timer	= (Tcl_TimerToken) NULL;
+    dataPtr->maxRead	= 4096; /* Initial value not relevant */
+    dataPtr->interp	= interp;
+    dataPtr->command	= cmdObjPtr;
+
+    Tcl_IncrRefCount(dataPtr->command);
+
+    ResultInit(&dataPtr->result);
+
+    dataPtr->self = Tcl_StackChannel(interp, &transformChannelType,
+	    (ClientData) dataPtr, mode, chan);
+    if (dataPtr->self == (Tcl_Channel) NULL) {
+	Tcl_AppendResult(interp, "\nfailed to stack channel \"",
+		Tcl_GetChannelName(chan), "\"", (char *) NULL);
+
+	Tcl_DecrRefCount(dataPtr->command);
+	ResultClear(&dataPtr->result);
+	ckfree((VOID *) dataPtr);
+	return TCL_ERROR;
+    }
+
+    /*
+     * At last initialize the transformation at the script level.
+     */
+
+    if (dataPtr->mode & TCL_WRITABLE) {
+	res = ExecuteCallback (dataPtr, NO_INTERP, A_CREATE_WRITE,
+		NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+
+	if (res != TCL_OK) {
+	    Tcl_UnstackChannel(interp, chan);
+	    return TCL_ERROR;
+	}
+    }
+
+    if (dataPtr->mode & TCL_READABLE) {
+	res = ExecuteCallback (dataPtr, NO_INTERP, A_CREATE_READ,
+		NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+
+	if (res != TCL_OK) {
+	    ExecuteCallback (dataPtr, NO_INTERP, A_DELETE_WRITE,
+		    NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+
+	    Tcl_UnstackChannel(interp, chan);
+	    return TCL_ERROR;
+	}
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ExecuteCallback --
+ *
+ *	Executes the defined callback for buffer and
+ *	operation.
+ *
+ *	Sideeffects:
+ *		As of the executed tcl script.
+ *
+ *	Result:
+ *		A standard TCL error code. In case of an
+ *		error a message is left in the result area
+ *		of the specified interpreter.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
+    TransformChannelData* dataPtr;     /* Transformation with the callback */
+    Tcl_Interp*           interp;   /* Current interpreter, possibly NULL */
+    unsigned char*        op;       /* Operation invoking the callback */
+    unsigned char*        buf;      /* Buffer to give to the script. */
+    int                   bufLen;   /* Ands its length */
+    int                   transmit; /* Flag, determines whether the result
+				     * of the callback is sent to the
+				     * underlying channel or not. */
+    int                   preserve; /* Flag. If true the procedure will
+				     * preserver the result state of all
+				     * accessed interpreters. */
+{
+    /*
+     * Step 1, create the complete command to execute. Do this by appending
+     * operation and buffer to operate upon to a copy of the callback
+     * definition. We *cannot* create a list containing 3 objects and then use
+     * 'Tcl_EvalObjv', because the command may contain additional prefixed
+     * arguments. Feather's curried commands would come in handy here.
+     */
+
+    Tcl_Obj*        resObj; /* See below, switch (transmit) */
+    int             resLen;
+    unsigned char*  resBuf;
+    Tcl_SavedResult ciSave;
+
+    int res = TCL_OK;
+    Tcl_Obj* command = Tcl_DuplicateObj (dataPtr->command);
+    Tcl_Obj* temp;
+
+
+    if (preserve) {
+	Tcl_SaveResult (dataPtr->interp, &ciSave);
+    }
+
+    if (command == (Tcl_Obj*) NULL) {
+        /* Memory allocation problem */
+        res = TCL_ERROR;
+        goto cleanup;
+    }
+
+    Tcl_IncrRefCount(command);
+
+    temp = Tcl_NewStringObj((char*) op, -1);
+
+    if (temp == (Tcl_Obj*) NULL) {
+        /* Memory allocation problem */
+        res = TCL_ERROR;
+        goto cleanup;
+    }
+
+    res = Tcl_ListObjAppendElement(dataPtr->interp, command, temp);
+
+    if (res != TCL_OK)
+	goto cleanup;
+
+    /*
+     * Use a byte-array to prevent the misinterpretation of binary data
+     * coming through as UTF while at the tcl level.
+     */
+
+    temp = Tcl_NewByteArrayObj(buf, bufLen);
+
+    if (temp == (Tcl_Obj*) NULL) {
+        /* Memory allocation problem */
+	res = TCL_ERROR;
+        goto cleanup;
+    }
+
+    res = Tcl_ListObjAppendElement (dataPtr->interp, command, temp);
+
+    if (res != TCL_OK)
+        goto cleanup;
+
+    /*
+     * Step 2, execute the command at the global level of the interpreter
+     * used to create the transformation. Destroy the command afterward.
+     * If an error occured and the current interpreter is defined and not
+     * equal to the interpreter for the callback, then copy the error
+     * message into current interpreter. Don't copy if in preservation mode.
+     */
+
+    res = Tcl_GlobalEvalObj (dataPtr->interp, command);
+    Tcl_DecrRefCount (command);
+    command = (Tcl_Obj*) NULL;
+
+    if ((res != TCL_OK) && (interp != NO_INTERP) &&
+	    (dataPtr->interp != interp) && !preserve) {
+        Tcl_SetObjResult(interp, Tcl_GetObjResult(dataPtr->interp));
+	return res;
+    }
+
+    /*
+     * Step 3, transmit a possible conversion result to the underlying
+     * channel, or ourselves.
+     */
+
+    switch (transmit) {
+	case TRANSMIT_DONT:
+	    /* nothing to do */
+	    break;
+
+	case TRANSMIT_DOWN:
+	    resObj = Tcl_GetObjResult(dataPtr->interp);
+	    resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
+	    Tcl_WriteRaw(Tcl_GetStackedChannel(dataPtr->self),
+		    (char*) resBuf, resLen);
+	    break;
+
+	case TRANSMIT_SELF:
+	    resObj = Tcl_GetObjResult (dataPtr->interp);
+	    resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
+	    Tcl_WriteRaw(dataPtr->self, (char*) resBuf, resLen);
+	    break;
+
+	case TRANSMIT_IBUF:
+	    resObj = Tcl_GetObjResult (dataPtr->interp);
+	    resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
+	    ResultAdd(&dataPtr->result, resBuf, resLen);
+	    break;
+
+	case TRANSMIT_NUM:
+	    /* Interpret result as integer number */
+	    resObj = Tcl_GetObjResult (dataPtr->interp);
+	    Tcl_GetIntFromObj(dataPtr->interp, resObj, &dataPtr->maxRead);
+	    break;
+    }
+
+    Tcl_ResetResult(dataPtr->interp);
+
+    if (preserve) {
+	Tcl_RestoreResult(dataPtr->interp, &ciSave);
+    }
+
+    return res;
+
+    cleanup:
+    if (preserve) {
+	Tcl_RestoreResult(dataPtr->interp, &ciSave);
+    }
+
+    if (command != (Tcl_Obj*) NULL) {
+        Tcl_DecrRefCount(command);
+    }
+
+    return res;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformBlockModeProc --
+ *
+ *	Trap handler. Called by the generic IO system
+ *	during option processing to change the blocking
+ *	mode of the channel.
+ *
+ *	Sideeffects:
+ *		Forwards the request to the underlying
+ *		channel.
+ *
+ *	Result:
+ *		0 if successful, errno when failed.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformBlockModeProc (instanceData, mode)
+    ClientData  instanceData; /* State of transformation */
+    int         mode;         /* New blocking mode */
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+
+    if (mode == TCL_MODE_NONBLOCKING) {
+        dataPtr->flags |= CHANNEL_ASYNC;
+    } else {
+        dataPtr->flags &= ~(CHANNEL_ASYNC);
+    }
+    return 0;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformCloseProc --
+ *
+ *	Trap handler. Called by the generic IO system
+ *	during destruction of the transformation channel.
+ *
+ *	Sideeffects:
+ *		Releases the memory allocated in
+ *		'Tcl_TransformObjCmd'.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformCloseProc (instanceData, interp)
+    ClientData  instanceData;
+    Tcl_Interp* interp;
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+
+    /*
+     * Important: In this procedure 'dataPtr->self' already points to
+     * the underlying channel.
+     */
+
+    /*
+     * There is no need to cancel an existing channel handler, this is already
+     * done. Either by 'Tcl_UnstackChannel' or by the general cleanup in
+     * 'Tcl_Close'.
+     *
+     * But we have to cancel an active timer to prevent it from firing on the
+     * removed channel.
+     */
+
+    if (dataPtr->timer != (Tcl_TimerToken) NULL) {
+        Tcl_DeleteTimerHandler (dataPtr->timer);
+	dataPtr->timer = (Tcl_TimerToken) NULL;
+    }
+
+    /*
+     * Now flush data waiting in internal buffers to output and input. The
+     * input must be done despite the fact that there is no real receiver
+     * for it anymore. But the scripts might have sideeffects other parts
+     * of the system rely on (f.e. signaling the close to interested parties).
+     */
+
+    if (dataPtr->mode & TCL_WRITABLE) {
+        ExecuteCallback (dataPtr, interp, A_FLUSH_WRITE,
+		NULL, 0, TRANSMIT_DOWN, 1);
+    }
+
+    if ((dataPtr->mode & TCL_READABLE) && !dataPtr->readIsFlushed) {
+	dataPtr->readIsFlushed = 1;
+        ExecuteCallback (dataPtr, interp, A_FLUSH_READ,
+		NULL, 0, TRANSMIT_IBUF, 1);
+    }
+
+    if (dataPtr->mode & TCL_WRITABLE) {
+        ExecuteCallback (dataPtr, interp, A_DELETE_WRITE,
+		NULL, 0, TRANSMIT_DONT, 1);
+    }
+
+    if (dataPtr->mode & TCL_READABLE) {
+        ExecuteCallback (dataPtr, interp, A_DELETE_READ,
+		NULL, 0, TRANSMIT_DONT, 1);
+    }
+
+    /*
+     * General cleanup
+     */
+
+    ResultClear(&dataPtr->result);
+    Tcl_DecrRefCount(dataPtr->command);
+    ckfree((VOID*) dataPtr);
+
+    return TCL_OK;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformInputProc --
+ *
+ *	Called by the generic IO system to convert read data.
+ *
+ *	Sideeffects:
+ *		As defined by the conversion.
+ *
+ *	Result:
+ *		A transformed buffer.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformInputProc (instanceData, buf, toRead, errorCodePtr)
+    ClientData instanceData;
+    char*      buf;
+    int        toRead;
+    int*       errorCodePtr;
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+    int gotBytes, read, res, copied;
+    Tcl_Channel downChan;
+
+    /* should assert (dataPtr->mode & TCL_READABLE) */
+
+    if (toRead == 0) {
+	/* Catch a no-op.
+	 */
+	return 0;
+    }
+
+    gotBytes = 0;
+    downChan = Tcl_GetStackedChannel(dataPtr->self);
+
+    while (toRead > 0) {
+        /*
+	 * Loop until the request is satisfied (or no data is available from
+	 * below, possibly EOF).
+	 */
+
+        copied    = ResultCopy (&dataPtr->result, UCHARP (buf), toRead);
+
+	toRead   -= copied;
+	buf      += copied;
+	gotBytes += copied;
+
+	if (toRead == 0) {
+	    /* The request was completely satisfied from our buffers.
+	     * We can break out of the loop and return to the caller.
+	     */
+	    return gotBytes;
+	}
+
+	/*
+	 * Length (dataPtr->result) == 0, toRead > 0 here . Use the incoming
+	 * 'buf'! as target to store the intermediary information read
+	 * from the underlying channel.
+	 *
+	 * Ask the tcl level how much data it allows us to read from
+	 * the underlying channel. This feature allows the transform to
+	 * signal EOF upstream although there is none downstream. Useful
+	 * to control an unbounded 'fcopy', either through counting bytes,
+	 * or by pattern matching.
+	 */
+
+	ExecuteCallback (dataPtr, NO_INTERP, A_QUERY_MAXREAD,
+		NULL, 0, TRANSMIT_NUM /* -> maxRead */, 1);
+
+	if (dataPtr->maxRead >= 0) {
+	    if (dataPtr->maxRead < toRead) {
+	        toRead = dataPtr->maxRead;
+	    }
+	} /* else: 'maxRead < 0' == Accept the current value of toRead */
+
+	if (toRead <= 0) {
+	    return gotBytes;
+	}
+
+	read = Tcl_ReadRaw(downChan, buf, toRead);
+
+	if (read < 0) {
+	    /* Report errors to caller. EAGAIN is a special situation.
+	     * If we had some data before we report that instead of the
+	     * request to re-try.
+	     */
+
+	    if ((Tcl_GetErrno() == EAGAIN) && (gotBytes > 0)) {
+	        return gotBytes;
+	    }
+
+	    *errorCodePtr = Tcl_GetErrno();
+	    return -1;      
+	}
+
+	if (read == 0) {
+	    /*
+	     * Check wether we hit on EOF in the underlying channel or
+	     * not. If not differentiate between blocking and
+	     * non-blocking modes. In non-blocking mode we ran
+	     * temporarily out of data. Signal this to the caller via
+	     * EWOULDBLOCK and error return (-1). In the other cases
+	     * we simply return what we got and let the caller wait
+	     * for more. On the other hand, if we got an EOF we have
+	     * to convert and flush all waiting partial data.
+	     */
+
+	    if (! Tcl_Eof (downChan)) {
+	        if ((gotBytes == 0) && (dataPtr->flags & CHANNEL_ASYNC)) {
+		    *errorCodePtr = EWOULDBLOCK;
+		    return -1;
+		} else {
+		    return gotBytes;
+		}
+	    } else {
+	        if (dataPtr->readIsFlushed) {
+		    /* Already flushed, nothing to do anymore
+		     */
+		    return gotBytes;
+		}
+
+		dataPtr->readIsFlushed = 1;
+
+		ExecuteCallback (dataPtr, NO_INTERP, A_FLUSH_READ,
+			NULL, 0, TRANSMIT_IBUF, P_PRESERVE);
+
+		if (ResultLength (&dataPtr->result) == 0) {
+		    /* we had nothing to flush */
+		    return gotBytes;
+		}
+
+		continue; /* at: while (toRead > 0) */
+	    }
+	} /* read == 0 */
+
+	/* Transform the read chunk and add the result to our
+	 * read buffer (dataPtr->result)
+	 */
+
+	res = ExecuteCallback (dataPtr, NO_INTERP, A_READ,
+		UCHARP (buf), read, TRANSMIT_IBUF,
+		P_PRESERVE);
+
+	if (res != TCL_OK) {
+	    *errorCodePtr = EINVAL;
+	    return -1;
+	}
+    } /* while toRead > 0 */
+
+    return gotBytes;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformOutputProc --
+ *
+ *	Called by the generic IO system to convert data
+ *	waiting to be written.
+ *
+ *	Sideeffects:
+ *		As defined by the transformation.
+ *
+ *	Result:
+ *		A transformed buffer.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformOutputProc (instanceData, buf, toWrite, errorCodePtr)
+    ClientData instanceData;
+    char*      buf;
+    int        toWrite;
+    int*       errorCodePtr;
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+    int res;
+
+    /* should assert (dataPtr->mode & TCL_WRITABLE) */
+
+    if (toWrite == 0) {
+	/* Catch a no-op.
+	 */
+	return 0;
+    }
+
+    res = ExecuteCallback (dataPtr, NO_INTERP, A_WRITE,
+	    UCHARP (buf), toWrite,
+	    TRANSMIT_DOWN, P_NO_PRESERVE);
+
+    if (res != TCL_OK) {
+        *errorCodePtr = EINVAL;
+	return -1;
+    }
+
+    return toWrite;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformSeekProc --
+ *
+ *	This procedure is called by the generic IO level
+ *	to move the access point in a channel.
+ *
+ *	Sideeffects:
+ *		Moves the location at which the channel
+ *		will be accessed in future operations.
+ *		Flushes all transformation buffers, then
+ *		forwards it to the underlying channel.
+ *
+ *	Result:
+ *		-1 if failed, the new position if
+ *		successful. An output argument contains
+ *		the POSIX error code if an error
+ *		occurred, or zero.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformSeekProc (instanceData, offset, mode, errorCodePtr)
+    ClientData instanceData;	/* The channel to manipulate */
+    long       offset;		/* Size of movement. */
+    int        mode;		/* How to move */
+    int*       errorCodePtr;	/* Location of error flag. */
+{
+    int result;
+    TransformChannelData* dataPtr	= (TransformChannelData*) instanceData;
+    Tcl_Channel           parent        = Tcl_GetStackedChannel(dataPtr->self);
+    Tcl_ChannelType*      parentType	= Tcl_GetChannelType(parent);
+    Tcl_DriverSeekProc*   parentSeekProc = Tcl_ChannelSeekProc(parentType);
+
+    if ((offset == 0) && (mode == SEEK_CUR)) {
+        /* This is no seek but a request to tell the caller the current
+	 * location. Simply pass the request down.
+	 */
+
+	result = (*parentSeekProc) (Tcl_GetChannelInstanceData(parent),
+		offset, mode, errorCodePtr);
+	return result;
+    }
+
+    /*
+     * It is a real request to change the position. Flush all data waiting
+     * for output and discard everything in the input buffers. Then pass
+     * the request down, unchanged.
+     */
+
+    if (dataPtr->mode & TCL_WRITABLE) {
+        ExecuteCallback (dataPtr, NO_INTERP, A_FLUSH_WRITE,
+		NULL, 0, TRANSMIT_DOWN, P_NO_PRESERVE);
+    }
+
+    if (dataPtr->mode & TCL_READABLE) {
+        ExecuteCallback (dataPtr, NO_INTERP, A_CLEAR_READ,
+		NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+	ResultClear(&dataPtr->result);
+	dataPtr->readIsFlushed = 0;
+    }
+
+    result = (*parentSeekProc) (Tcl_GetChannelInstanceData(parent),
+	    offset, mode, errorCodePtr);
+    return result;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformSetOptionProc --
+ *
+ *	Called by generic layer to handle the reconfi-
+ *	guration of channel specific options. As this
+ *	channel type does not have such, it simply passes
+ *	all requests downstream.
+ *
+ *	Sideeffects:
+ *		As defined by the channel downstream.
+ *
+ *	Result:
+ *		A standard TCL error code.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformSetOptionProc (instanceData, interp, optionName, value)
+    ClientData instanceData;
+    Tcl_Interp *interp;
+    char *optionName;
+    char *value;
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+    Tcl_Channel downChan = Tcl_GetStackedChannel(dataPtr->self);
+    Tcl_DriverSetOptionProc *setOptionProc;
+
+    setOptionProc = Tcl_ChannelSetOptionProc(Tcl_GetChannelType(downChan));
+    if (setOptionProc != NULL) {
+	return (*setOptionProc)(Tcl_GetChannelInstanceData(downChan),
+		interp, optionName, value);
+    }
+    return TCL_ERROR;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformGetOptionProc --
+ *
+ *	Called by generic layer to handle requests for
+ *	the values of channel specific options. As this
+ *	channel type does not have such, it simply passes
+ *	all requests downstream.
+ *
+ *	Sideeffects:
+ *		As defined by the channel downstream.
+ *
+ *	Result:
+ *		A standard TCL error code.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformGetOptionProc (instanceData, interp, optionName, dsPtr)
+    ClientData   instanceData;
+    Tcl_Interp*  interp;
+    char*        optionName;
+    Tcl_DString* dsPtr;
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+    Tcl_Channel downChan = Tcl_GetStackedChannel(dataPtr->self);
+    Tcl_DriverGetOptionProc *getOptionProc;
+
+    getOptionProc = Tcl_ChannelGetOptionProc(Tcl_GetChannelType(downChan));
+    if (getOptionProc != NULL) {
+	return (*getOptionProc)(Tcl_GetChannelInstanceData(downChan),
+		interp, optionName, dsPtr);
+    } else if (optionName == (char*) NULL) {
+	/*
+	 * Request is query for all options, this is ok.
+	 */
+	return TCL_OK;
+    }
+    /*
+     * Request for a specific option has to fail, we don't have any.
+     */
+    return TCL_ERROR;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformWatchProc --
+ *
+ *	Initialize the notifier to watch for events from
+ *	this channel.
+ *
+ *	Sideeffects:
+ *		Sets up the notifier so that a future
+ *		event on the channel will be seen by Tcl.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+	/* ARGSUSED */
+static void
+TransformWatchProc (instanceData, mask)
+    ClientData instanceData;	/* Channel to watch */
+    int        mask;		/* Events of interest */
+{
+    /* The caller expressed interest in events occuring for this
+     * channel. We are forwarding the call to the underlying
+     * channel now.
+     */
+
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+    Tcl_Channel     downChan;
+
+    dataPtr->watchMask = mask;
+
+    /* No channel handlers any more. We will be notified automatically
+     * about events on the channel below via a call to our
+     * 'TransformNotifyProc'. But we have to pass the interest down now.
+     * We are allowed to add additional 'interest' to the mask if we want
+     * to. But this transformation has no such interest. It just passes
+     * the request down, unchanged.
+     */
+
+    downChan = Tcl_GetStackedChannel(dataPtr->self);
+
+    (Tcl_GetChannelType(downChan))
+	->watchProc(Tcl_GetChannelInstanceData(downChan), mask);
+
+    /*
+     * Management of the internal timer.
+     */
+
+    if ((dataPtr->timer != (Tcl_TimerToken) NULL) &&
+	    (!(mask & TCL_READABLE) || (ResultLength(&dataPtr->result) == 0))) {
+
+        /* A pending timer exists, but either is there no (more)
+	 * interest in the events it generates or nothing is availablee
+	 * for reading, so remove it.
+	 */
+
+        Tcl_DeleteTimerHandler (dataPtr->timer);
+	dataPtr->timer = (Tcl_TimerToken) NULL;
+    }
+
+    if ((dataPtr->timer == (Tcl_TimerToken) NULL) &&
+	    (mask & TCL_READABLE) && (ResultLength (&dataPtr->result) > 0)) {
+
+        /* There is no pending timer, but there is interest in readable
+	 * events and we actually have data waiting, so generate a timer
+	 * to flush that.
+	 */
+
+	dataPtr->timer = Tcl_CreateTimerHandler (DELAY,
+		TransformChannelHandlerTimer, (ClientData) dataPtr);
+    }
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformGetFileHandleProc --
+ *
+ *	Called from Tcl_GetChannelHandle to retrieve
+ *	OS specific file handle from inside this channel.
+ *
+ *	Sideeffects:
+ *		None.
+ *
+ *	Result:
+ *		The appropriate Tcl_File or NULL if not
+ *		present. 
+ *
+ *------------------------------------------------------*
+ */
+static int
+TransformGetFileHandleProc (instanceData, direction, handlePtr)
+    ClientData  instanceData;	/* Channel to query */
+    int         direction;	/* Direction of interest */
+    ClientData* handlePtr;	/* Place to store the handle into */
+{
+    /*
+     * Return the handle belonging to parent channel.
+     * IOW, pass the request down and the result up.
+     */
+
+    TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+
+    return Tcl_GetChannelHandle(Tcl_GetStackedChannel(dataPtr->self),
+	    direction, handlePtr);
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformNotifyProc --
+ *
+ *	------------------------------------------------*
+ *	Handler called by Tcl to inform us of activity
+ *	on the underlying channel.
+ *	------------------------------------------------*
+ *
+ *	Sideeffects:
+ *		May process the incoming event by itself.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+TransformNotifyProc (clientData, mask)
+    ClientData	   clientData; /* The state of the notified transformation */
+    int		   mask;       /* The mask of occuring events */
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) clientData;
+
+    /*
+     * An event occured in the underlying channel.  This
+     * transformation doesn't process such events thus returns the
+     * incoming mask unchanged.
+     */
+
+    if (dataPtr->timer != (Tcl_TimerToken) NULL) {
+	/*
+	 * Delete an existing timer. It was not fired, yet we are
+	 * here, so the channel below generated such an event and we
+	 * don't have to. The renewal of the interest after the
+	 * execution of channel handlers will eventually cause us to
+	 * recreate the timer (in TransformWatchProc).
+	 */
+
+	Tcl_DeleteTimerHandler (dataPtr->timer);
+	dataPtr->timer = (Tcl_TimerToken) NULL;
+    }
+
+    return mask;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	TransformChannelHandlerTimer --
+ *
+ *	Called by the notifier (-> timer) to flush out
+ *	information waiting in the input buffer.
+ *
+ *	Sideeffects:
+ *		As of 'Tcl_NotifyChannel'.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static void
+TransformChannelHandlerTimer (clientData)
+    ClientData clientData; /* Transformation to query */
+{
+    TransformChannelData* dataPtr = (TransformChannelData*) clientData;
+
+    dataPtr->timer = (Tcl_TimerToken) NULL;
+
+    if (!(dataPtr->watchMask & TCL_READABLE) ||
+	    (ResultLength (&dataPtr->result) == 0)) {
+	/* The timer fired, but either is there no (more)
+	 * interest in the events it generates or nothing is available
+	 * for reading, so ignore it and don't recreate it.
+	 */
+
+	return;
+    }
+
+    Tcl_NotifyChannel(dataPtr->self, TCL_READABLE);
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ResultClear --
+ *
+ *	Deallocates any memory allocated by 'ResultAdd'.
+ *
+ *	Sideeffects:
+ *		See above.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static void
+ResultClear (r)
+    ResultBuffer* r; /* Reference to the buffer to clear out */
+{
+    r->used = 0;
+
+    if (r->allocated) {
+        ckfree((char*) r->buf);
+	r->buf       = UCHARP (NULL);
+	r->allocated = 0;
+    }
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ResultInit --
+ *
+ *	Initializes the specified buffer structure. The
+ *	structure will contain valid information for an
+ *	emtpy buffer.
+ *
+ *	Sideeffects:
+ *		See above.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static void
+ResultInit (r)
+    ResultBuffer* r; /* Reference to the structure to initialize */
+{
+    r->used      = 0;
+    r->allocated = 0;
+    r->buf       = UCHARP (NULL);
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ResultLength --
+ *
+ *	Returns the number of bytes stored in the buffer.
+ *
+ *	Sideeffects:
+ *		None.
+ *
+ *	Result:
+ *		An integer, see above too.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+ResultLength (r)
+    ResultBuffer* r; /* The structure to query */
+{
+    return r->used;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ResultCopy --
+ *
+ *	Copies the requested number of bytes from the
+ *	buffer into the specified array and removes them
+ *	from the buffer afterward. Copies less if there
+ *	is not enough data in the buffer.
+ *
+ *	Sideeffects:
+ *		See above.
+ *
+ *	Result:
+ *		The number of actually copied bytes,
+ *		possibly less than 'toRead'.
+ *
+ *------------------------------------------------------*
+ */
+
+static int
+ResultCopy (r, buf, toRead)
+    ResultBuffer*  r;      /* The buffer to read from */
+    unsigned char* buf;    /* The buffer to copy into */
+    int            toRead; /* Number of requested bytes */
+{
+    if (r->used == 0) {
+        /* Nothing to copy in the case of an empty buffer.
+	 */
+
+        return 0;
+    }
+
+    if (r->used == toRead) {
+        /* We have just enough. Copy everything to the caller.
+	 */
+
+        memcpy ((VOID*) buf, (VOID*) r->buf, (size_t) toRead);
+	r->used = 0;
+	return toRead;
+    }
+
+    if (r->used > toRead) {
+        /* The internal buffer contains more than requested.
+	 * Copy the requested subset to the caller, and shift
+	 * the remaining bytes down.
+	 */
+
+        memcpy  ((VOID*) buf,    (VOID*) r->buf,            (size_t) toRead);
+	memmove ((VOID*) r->buf, (VOID*) (r->buf + toRead),
+		(size_t) r->used - toRead);
+
+	r->used -= toRead;
+	return toRead;
+    }
+
+    /* There is not enough in the buffer to satisfy the caller, so
+     * take everything.
+     */
+
+    memcpy((VOID*) buf, (VOID*) r->buf, (size_t) r->used);
+    toRead  = r->used;
+    r->used = 0;
+    return toRead;
+}
+
+/*
+ *------------------------------------------------------*
+ *
+ *	ResultAdd --
+ *
+ *	Adds the bytes in the specified array to the
+ *	buffer, by appending it.
+ *
+ *	Sideeffects:
+ *		See above.
+ *
+ *	Result:
+ *		None.
+ *
+ *------------------------------------------------------*
+ */
+
+static void
+ResultAdd (r, buf, toWrite)
+    ResultBuffer*  r;       /* The buffer to extend */
+    unsigned char* buf;     /* The buffer to read from */
+    int            toWrite; /* The number of bytes in 'buf' */
+{
+    if ((r->used + toWrite) > r->allocated) {
+        /* Extension of the internal buffer is required.
+	 */
+
+        if (r->allocated == 0) {
+	    r->allocated = toWrite + INCREMENT;
+	    r->buf       = UCHARP (ckalloc((unsigned) r->allocated));
+	} else {
+	    r->allocated += toWrite + INCREMENT;
+	    r->buf        = UCHARP (ckrealloc((char*) r->buf,
+		    (unsigned) r->allocated));
+	}
+    }
+
+    /* now copy data */
+    memcpy(r->buf + r->used, buf, (size_t) toWrite);
+    r->used += toWrite;
+}
diff --git a/generic/tclInt.decls b/generic/tclInt.decls
index 25e2572..a61d82b 100644
--- a/generic/tclInt.decls
+++ b/generic/tclInt.decls
@@ -10,7 +10,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 # 
-# RCS: @(#) $Id: tclInt.decls,v 1.22 2000/07/26 01:28:49 davidg Exp $
+# RCS: @(#) $Id: tclInt.decls,v 1.23 2000/09/28 06:38:21 hobbs Exp $
 
 library tcl
 
@@ -577,6 +577,7 @@ declare 153 generic {
     Tcl_Obj *TclGetLibraryPath(void)
 }
 
+# moved to tclTest.c (static) in 8.3.2/8.4a2
 #declare 154 generic {
 #    int TclTestChannelCmd(ClientData clientData,
 #    Tcl_Interp *interp, int argc, char **argv)
@@ -604,8 +605,13 @@ declare 160 generic {
 	    Tcl_DString *dirPtr, char *pattern, char *tail, GlobTypeData *types)
 }
 
+# new in 8.3.2/8.4a2
 declare 161 generic {
-    void TclChannelEventScriptInvoker(ClientData clientData, int mask)
+    int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan, \
+	    Tcl_Obj *cmdObjPtr)
+}
+declare 162 generic {
+    void TclChannelEventScriptInvoker(ClientData clientData, int flags)
 }
 
 ##############################################################################
diff --git a/generic/tclIntDecls.h b/generic/tclIntDecls.h
index 03dbed4..fabbe06 100644
--- a/generic/tclIntDecls.h
+++ b/generic/tclIntDecls.h
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclIntDecls.h,v 1.20 2000/05/19 21:30:16 hobbs Exp $
+ * RCS: @(#) $Id: tclIntDecls.h,v 1.21 2000/09/28 06:38:21 hobbs Exp $
  */
 
 #ifndef _TCLINTDECLS
@@ -525,8 +525,11 @@ EXTERN int		TclpMatchFilesTypes _ANSI_ARGS_((Tcl_Interp * interp,
 				char * pattern, char * tail, 
 				GlobTypeData * types));
 /* 161 */
+EXTERN int		TclChannelTransform _ANSI_ARGS_((Tcl_Interp * interp, 
+				Tcl_Channel chan, Tcl_Obj * cmdObjPtr));
+/* 162 */
 EXTERN void		TclChannelEventScriptInvoker _ANSI_ARGS_((
-				ClientData clientData, int mask));
+				ClientData clientData, int flags));
 
 typedef struct TclIntStubs {
     int magic;
@@ -725,7 +728,8 @@ typedef struct TclIntStubs {
     void (*tclSetStartupScriptFileName) _ANSI_ARGS_((char * filename)); /* 158 */
     char * (*tclGetStartupScriptFileName) _ANSI_ARGS_((void)); /* 159 */
     int (*tclpMatchFilesTypes) _ANSI_ARGS_((Tcl_Interp * interp, char * separators, Tcl_DString * dirPtr, char * pattern, char * tail, GlobTypeData * types)); /* 160 */
-    void (*tclChannelEventScriptInvoker) _ANSI_ARGS_((ClientData clientData, int mask)); /* 161 */
+    int (*tclChannelTransform) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_Channel chan, Tcl_Obj * cmdObjPtr)); /* 161 */
+    void (*tclChannelEventScriptInvoker) _ANSI_ARGS_((ClientData clientData, int flags)); /* 162 */
 } TclIntStubs;
 
 #ifdef __cplusplus
@@ -1373,9 +1377,13 @@ extern TclIntStubs *tclIntStubsPtr;
 #define TclpMatchFilesTypes \
 	(tclIntStubsPtr->tclpMatchFilesTypes) /* 160 */
 #endif
+#ifndef TclChannelTransform
+#define TclChannelTransform \
+	(tclIntStubsPtr->tclChannelTransform) /* 161 */
+#endif
 #ifndef TclChannelEventScriptInvoker
 #define TclChannelEventScriptInvoker \
-	(tclIntStubsPtr->tclChannelEventScriptInvoker) /* 161 */
+	(tclIntStubsPtr->tclChannelEventScriptInvoker) /* 162 */
 #endif
 
 #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c
index dbd5372..c716732 100644
--- a/generic/tclStubInit.c
+++ b/generic/tclStubInit.c
@@ -8,7 +8,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclStubInit.c,v 1.44 2000/09/14 18:42:32 ericm Exp $
+ * RCS: @(#) $Id: tclStubInit.c,v 1.45 2000/09/28 06:38:22 hobbs Exp $
  */
 
 #include "tclInt.h"
@@ -240,7 +240,8 @@ TclIntStubs tclIntStubs = {
     TclSetStartupScriptFileName, /* 158 */
     TclGetStartupScriptFileName, /* 159 */
     TclpMatchFilesTypes, /* 160 */
-    TclChannelEventScriptInvoker, /* 161 */
+    TclChannelTransform, /* 161 */
+    TclChannelEventScriptInvoker, /* 162 */
 };
 
 TclIntPlatStubs tclIntPlatStubs = {
@@ -796,27 +797,45 @@ TclStubs tclStubs = {
     Tcl_ConditionFinalize, /* 391 */
     Tcl_MutexFinalize, /* 392 */
     Tcl_CreateThread, /* 393 */
-    Tcl_JoinThread, /* 394 */
-    Tcl_IsChannelShared, /* 395 */
-    Tcl_IsChannelRegistered, /* 396 */
-    Tcl_CutChannel, /* 397 */
-    Tcl_SpliceChannel, /* 398 */
-    Tcl_ClearChannelHandlers, /* 399 */
-    Tcl_IsChannelExisting, /* 400 */
-    Tcl_UniCharNcasecmp, /* 401 */
-    Tcl_UniCharCaseMatch, /* 402 */
-    Tcl_FindHashEntry, /* 403 */
-    Tcl_CreateHashEntry, /* 404 */
-    Tcl_InitHashTableEx, /* 405 */
-    Tcl_InitObjHashTable, /* 406 */
-    Tcl_CommandTraceInfo, /* 407 */
-    Tcl_TraceCommand, /* 408 */
-    Tcl_UntraceCommand, /* 409 */
-    Tcl_AttemptAlloc, /* 410 */
-    Tcl_AttemptDbCkalloc, /* 411 */
-    Tcl_AttemptRealloc, /* 412 */
-    Tcl_AttemptDbCkrealloc, /* 413 */
-    Tcl_AttemptSetObjLength, /* 414 */
+    Tcl_ReadRaw, /* 394 */
+    Tcl_WriteRaw, /* 395 */
+    Tcl_GetTopChannel, /* 396 */
+    Tcl_ChannelBuffered, /* 397 */
+    Tcl_ChannelName, /* 398 */
+    Tcl_ChannelVersion, /* 399 */
+    Tcl_ChannelBlockModeProc, /* 400 */
+    Tcl_ChannelCloseProc, /* 401 */
+    Tcl_ChannelClose2Proc, /* 402 */
+    Tcl_ChannelInputProc, /* 403 */
+    Tcl_ChannelOutputProc, /* 404 */
+    Tcl_ChannelSeekProc, /* 405 */
+    Tcl_ChannelSetOptionProc, /* 406 */
+    Tcl_ChannelGetOptionProc, /* 407 */
+    Tcl_ChannelWatchProc, /* 408 */
+    Tcl_ChannelGetHandleProc, /* 409 */
+    Tcl_ChannelFlushProc, /* 410 */
+    Tcl_ChannelHandlerProc, /* 411 */
+    Tcl_JoinThread, /* 412 */
+    Tcl_IsChannelShared, /* 413 */
+    Tcl_IsChannelRegistered, /* 414 */
+    Tcl_CutChannel, /* 415 */
+    Tcl_SpliceChannel, /* 416 */
+    Tcl_ClearChannelHandlers, /* 417 */
+    Tcl_IsChannelExisting, /* 418 */
+    Tcl_UniCharNcasecmp, /* 419 */
+    Tcl_UniCharCaseMatch, /* 420 */
+    Tcl_FindHashEntry, /* 421 */
+    Tcl_CreateHashEntry, /* 422 */
+    Tcl_InitHashTableEx, /* 423 */
+    Tcl_InitObjHashTable, /* 424 */
+    Tcl_CommandTraceInfo, /* 425 */
+    Tcl_TraceCommand, /* 426 */
+    Tcl_UntraceCommand, /* 427 */
+    Tcl_AttemptAlloc, /* 428 */
+    Tcl_AttemptDbCkalloc, /* 429 */
+    Tcl_AttemptRealloc, /* 430 */
+    Tcl_AttemptDbCkrealloc, /* 431 */
+    Tcl_AttemptSetObjLength, /* 432 */
 };
 
 /* !END!: Do not edit above this line. */
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 6f90e20..b76b978 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -8,12 +8,12 @@
  *
  * Copyright (c) 1993-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
- * Copyright (c) 1998-2000 by Scriptics Corporation.
+ * Copyright (c) 1998-2000 Ajuba Solutions.
  *
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclTest.c,v 1.20 2000/08/07 22:42:31 ericm Exp $
+ * RCS: @(#) $Id: tclTest.c,v 1.21 2000/09/28 06:38:22 hobbs Exp $
  */
 
 #define TCL_TEST
@@ -289,11 +289,9 @@ static int		TesttranslatefilenameCmd _ANSI_ARGS_((ClientData dummy,
 			    Tcl_Interp *interp, int argc, char **argv));
 static int		TestupvarCmd _ANSI_ARGS_((ClientData dummy,
 			    Tcl_Interp *interp, int argc, char **argv));
-
 static int              TestWrongNumArgsObjCmd _ANSI_ARGS_((
-			    ClientData clientData,
-                            Tcl_Interp *interp, int objc,
-			    Tcl_Obj *CONST objv[]));
+			    ClientData clientData, Tcl_Interp *interp,
+			    int objc, Tcl_Obj *CONST objv[]));
 static int		TestChannelCmd _ANSI_ARGS_((ClientData clientData,
 			    Tcl_Interp *interp, int argc, char **argv));
 static int		TestChannelEventCmd _ANSI_ARGS_((ClientData clientData,
@@ -4281,9 +4279,7 @@ TestOpenFileChannelProc3(interp, fileName, modeString, permissions)
  * TestChannelCmd --
  *
  *	Implements the Tcl "testchannel" debugging command and its
- *	subcommands. This is part of the testing environment but must be
- *	in this file instead of tclTest.c because it needs access to the
- *	fields of struct Channel.
+ *	subcommands. This is part of the testing environment.
  *
  * Results:
  *	A standard Tcl result.
@@ -4295,7 +4291,7 @@ TestOpenFileChannelProc3(interp, fileName, modeString, permissions)
  */
 
 	/* ARGSUSED */
-static int
+int
 TestChannelCmd(clientData, interp, argc, argv)
     ClientData clientData;	/* Not used. */
     Tcl_Interp *interp;		/* Interpreter for result. */
@@ -4307,11 +4303,13 @@ TestChannelCmd(clientData, interp, argc, argv)
     Tcl_HashSearch hSearch;	/* Search variable. */
     Tcl_HashEntry *hPtr;	/* Search variable. */
     Channel *chanPtr;		/* The actual channel. */
-    Tcl_Channel chan = NULL;	/* The opaque type. */
+    ChannelState *statePtr;	/* state info for channel */
+    Tcl_Channel chan;		/* The opaque type. */
     size_t len;			/* Length of subcommand string. */
     int IOQueued;		/* How much IO is queued inside channel? */
     ChannelBuffer *bufPtr;	/* For iterating over queued IO. */
     char buf[TCL_INTEGER_SPACE];/* For sprintf. */
+    int mode;			/* rw mode of the channel */
     
     if (argc < 2) {
         Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
@@ -4324,34 +4322,38 @@ TestChannelCmd(clientData, interp, argc, argv)
     chanPtr = (Channel *) NULL;
 
     if (argc > 2) {
-        chan = Tcl_GetChannel(interp, argv[2], NULL);
+        chan = Tcl_GetChannel(interp, argv[2], &mode);
         if (chan == (Tcl_Channel) NULL) {
             return TCL_ERROR;
         }
-        chanPtr = (Channel *) chan;
+        chanPtr		= (Channel *) chan;
+	statePtr	= chanPtr->state;
+        chanPtr		= statePtr->topChanPtr;
+	chan		= (Tcl_Channel) chanPtr;
+    } else {
+	/* lint */
+	statePtr	= NULL;
+	chan		= NULL;
     }
 
-    if ((cmdName[0] == 'c') &&
-            (strncmp(cmdName, "cut", len) == 0)) {
+    if ((cmdName[0] == 'c') && (strncmp(cmdName, "cut", len) == 0)) {
         if (argc != 3) {
-            Tcl_AppendResult(interp, "channel name required",
-                    (char *) NULL);
+            Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+                    " cut channelName\"", (char *) NULL);
             return TCL_ERROR;
         }
-        
-        Tcl_CutChannel (chan);
+        Tcl_CutChannel(chan);
         return TCL_OK;
     }
 
     if ((cmdName[0] == 'c') &&
-            (strncmp(cmdName, "forgetch", len) == 0)) {
+	    (strncmp(cmdName, "clearchannelhandlers", len) == 0)) {
         if (argc != 3) {
-            Tcl_AppendResult(interp, "channel name required",
-                    (char *) NULL);
+            Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+                    " clearchannelhandlers channelName\"", (char *) NULL);
             return TCL_ERROR;
         }
-        
-        Tcl_ClearChannelHandlers (chan);
+        Tcl_ClearChannelHandlers(chan);
         return TCL_OK;
     }
 
@@ -4362,90 +4364,90 @@ TestChannelCmd(clientData, interp, argc, argv)
             return TCL_ERROR;
         }
         Tcl_AppendElement(interp, argv[2]);
-        Tcl_AppendElement(interp, chanPtr->typePtr->typeName);
-        if (chanPtr->flags & TCL_READABLE) {
+        Tcl_AppendElement(interp, Tcl_ChannelName(chanPtr->typePtr));
+        if (statePtr->flags & TCL_READABLE) {
             Tcl_AppendElement(interp, "read");
         } else {
             Tcl_AppendElement(interp, "");
         }
-        if (chanPtr->flags & TCL_WRITABLE) {
+        if (statePtr->flags & TCL_WRITABLE) {
             Tcl_AppendElement(interp, "write");
         } else {
             Tcl_AppendElement(interp, "");
         }
-        if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+        if (statePtr->flags & CHANNEL_NONBLOCKING) {
             Tcl_AppendElement(interp, "nonblocking");
         } else {
             Tcl_AppendElement(interp, "blocking");
         }
-        if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
+        if (statePtr->flags & CHANNEL_LINEBUFFERED) {
             Tcl_AppendElement(interp, "line");
-        } else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
+        } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
             Tcl_AppendElement(interp, "none");
         } else {
             Tcl_AppendElement(interp, "full");
         }
-        if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
+        if (statePtr->flags & BG_FLUSH_SCHEDULED) {
             Tcl_AppendElement(interp, "async_flush");
         } else {
             Tcl_AppendElement(interp, "");
         }
-        if (chanPtr->flags & CHANNEL_EOF) {
+        if (statePtr->flags & CHANNEL_EOF) {
             Tcl_AppendElement(interp, "eof");
         } else {
             Tcl_AppendElement(interp, "");
         }
-        if (chanPtr->flags & CHANNEL_BLOCKED) {
+        if (statePtr->flags & CHANNEL_BLOCKED) {
             Tcl_AppendElement(interp, "blocked");
         } else {
             Tcl_AppendElement(interp, "unblocked");
         }
-        if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
+        if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
             Tcl_AppendElement(interp, "auto");
-            if (chanPtr->flags & INPUT_SAW_CR) {
+            if (statePtr->flags & INPUT_SAW_CR) {
                 Tcl_AppendElement(interp, "saw_cr");
             } else {
                 Tcl_AppendElement(interp, "");
             }
-        } else if (chanPtr->inputTranslation == TCL_TRANSLATE_LF) {
+        } else if (statePtr->inputTranslation == TCL_TRANSLATE_LF) {
             Tcl_AppendElement(interp, "lf");
             Tcl_AppendElement(interp, "");
-        } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
+        } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
             Tcl_AppendElement(interp, "cr");
             Tcl_AppendElement(interp, "");
-        } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
+        } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
             Tcl_AppendElement(interp, "crlf");
-            if (chanPtr->flags & INPUT_SAW_CR) {
+            if (statePtr->flags & INPUT_SAW_CR) {
                 Tcl_AppendElement(interp, "queued_cr");
             } else {
                 Tcl_AppendElement(interp, "");
             }
         }
-        if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
+        if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
             Tcl_AppendElement(interp, "auto");
-        } else if (chanPtr->outputTranslation == TCL_TRANSLATE_LF) {
+        } else if (statePtr->outputTranslation == TCL_TRANSLATE_LF) {
             Tcl_AppendElement(interp, "lf");
-        } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
+        } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
             Tcl_AppendElement(interp, "cr");
-        } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
+        } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
             Tcl_AppendElement(interp, "crlf");
         }
-        for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
-                 bufPtr != (ChannelBuffer *) NULL;
-                 bufPtr = bufPtr->nextPtr) {
+        for (IOQueued = 0, bufPtr = statePtr->inQueueHead;
+	     bufPtr != (ChannelBuffer *) NULL;
+	     bufPtr = bufPtr->nextPtr) {
             IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
         }
         TclFormatInt(buf, IOQueued);
         Tcl_AppendElement(interp, buf);
         
         IOQueued = 0;
-        if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
-            IOQueued = chanPtr->curOutPtr->nextAdded -
-                chanPtr->curOutPtr->nextRemoved;
+        if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
+            IOQueued = statePtr->curOutPtr->nextAdded -
+                statePtr->curOutPtr->nextRemoved;
         }
-        for (bufPtr = chanPtr->outQueueHead;
-                 bufPtr != (ChannelBuffer *) NULL;
-                 bufPtr = bufPtr->nextPtr) {
+        for (bufPtr = statePtr->outQueueHead;
+	     bufPtr != (ChannelBuffer *) NULL;
+	     bufPtr = bufPtr->nextPtr) {
             IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
         }
         TclFormatInt(buf, IOQueued);
@@ -4454,7 +4456,7 @@ TestChannelCmd(clientData, interp, argc, argv)
         TclFormatInt(buf, Tcl_Tell((Tcl_Channel) chanPtr));
         Tcl_AppendElement(interp, buf);
 
-        TclFormatInt(buf, chanPtr->refCount);
+        TclFormatInt(buf, statePtr->refCount);
         Tcl_AppendElement(interp, buf);
 
         return TCL_OK;
@@ -4468,29 +4470,27 @@ TestChannelCmd(clientData, interp, argc, argv)
             return TCL_ERROR;
         }
         
-        for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
-                 bufPtr != (ChannelBuffer *) NULL;
-                 bufPtr = bufPtr->nextPtr) {
+        for (IOQueued = 0, bufPtr = statePtr->inQueueHead;
+	     bufPtr != (ChannelBuffer *) NULL;
+	     bufPtr = bufPtr->nextPtr) {
             IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
         }
         TclFormatInt(buf, IOQueued);
         Tcl_AppendResult(interp, buf, (char *) NULL);
         return TCL_OK;
     }
-        
-    if ((cmdName[0] == 'i') &&
-            (strncmp(cmdName, "isshared", len) == 0)) {
+
+    if ((cmdName[0] == 'i') && (strncmp(cmdName, "isshared", len) == 0)) {
         if (argc != 3) {
-            Tcl_AppendResult(interp, "channel name required",
-                    (char *) NULL);
+            Tcl_AppendResult(interp, "channel name required", (char *) NULL);
             return TCL_ERROR;
         }
         
-        TclFormatInt(buf, Tcl_IsChannelShared (chan));
+        TclFormatInt(buf, Tcl_IsChannelShared(chan));
         Tcl_AppendResult(interp, buf, (char *) NULL);
         return TCL_OK;
     }
-        
+
     if ((cmdName[0] == 'm') && (strncmp(cmdName, "mode", len) == 0)) {
         if (argc != 3) {
             Tcl_AppendResult(interp, "channel name required",
@@ -4498,12 +4498,12 @@ TestChannelCmd(clientData, interp, argc, argv)
             return TCL_ERROR;
         }
         
-        if (chanPtr->flags & TCL_READABLE) {
+        if (statePtr->flags & TCL_READABLE) {
             Tcl_AppendElement(interp, "read");
         } else {
             Tcl_AppendElement(interp, "");
         }
-        if (chanPtr->flags & TCL_WRITABLE) {
+        if (statePtr->flags & TCL_WRITABLE) {
             Tcl_AppendElement(interp, "write");
         } else {
             Tcl_AppendElement(interp, "");
@@ -4517,18 +4517,18 @@ TestChannelCmd(clientData, interp, argc, argv)
                     (char *) NULL);
             return TCL_ERROR;
         }
-        Tcl_AppendResult(interp, chanPtr->channelName, (char *) NULL);
+        Tcl_AppendResult(interp, statePtr->channelName, (char *) NULL);
         return TCL_OK;
     }
-    
+
     if ((cmdName[0] == 'o') && (strncmp(cmdName, "open", len) == 0)) {
         hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
         if (hTblPtr == (Tcl_HashTable *) NULL) {
             return TCL_OK;
         }
         for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
-                 hPtr != (Tcl_HashEntry *) NULL;
-                 hPtr = Tcl_NextHashEntry(&hSearch)) {
+	     hPtr != (Tcl_HashEntry *) NULL;
+	     hPtr = Tcl_NextHashEntry(&hSearch)) {
             Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
         }
         return TCL_OK;
@@ -4541,22 +4541,22 @@ TestChannelCmd(clientData, interp, argc, argv)
                     (char *) NULL);
             return TCL_ERROR;
         }
-        
+
         IOQueued = 0;
-        if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
-            IOQueued = chanPtr->curOutPtr->nextAdded -
-                chanPtr->curOutPtr->nextRemoved;
+        if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
+            IOQueued = statePtr->curOutPtr->nextAdded -
+                statePtr->curOutPtr->nextRemoved;
         }
-        for (bufPtr = chanPtr->outQueueHead;
-                 bufPtr != (ChannelBuffer *) NULL;
-                 bufPtr = bufPtr->nextPtr) {
+        for (bufPtr = statePtr->outQueueHead;
+	     bufPtr != (ChannelBuffer *) NULL;
+	     bufPtr = bufPtr->nextPtr) {
             IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
         }
         TclFormatInt(buf, IOQueued);
         Tcl_AppendResult(interp, buf, (char *) NULL);
         return TCL_OK;
     }
-        
+
     if ((cmdName[0] == 'q') &&
             (strncmp(cmdName, "queuedcr", len) == 0)) {
         if (argc != 3) {
@@ -4564,23 +4564,24 @@ TestChannelCmd(clientData, interp, argc, argv)
                     (char *) NULL);
             return TCL_ERROR;
         }
-        
+
         Tcl_AppendResult(interp,
-                (chanPtr->flags & INPUT_SAW_CR) ? "1" : "0",
+                (statePtr->flags & INPUT_SAW_CR) ? "1" : "0",
                 (char *) NULL);
         return TCL_OK;
     }
-    
+
     if ((cmdName[0] == 'r') && (strncmp(cmdName, "readable", len) == 0)) {
         hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
         if (hTblPtr == (Tcl_HashTable *) NULL) {
             return TCL_OK;
         }
         for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
-                 hPtr != (Tcl_HashEntry *) NULL;
-                 hPtr = Tcl_NextHashEntry(&hSearch)) {
-            chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
-            if (chanPtr->flags & TCL_READABLE) {
+	     hPtr != (Tcl_HashEntry *) NULL;
+	     hPtr = Tcl_NextHashEntry(&hSearch)) {
+            chanPtr  = (Channel *) Tcl_GetHashValue(hPtr);
+	    statePtr = chanPtr->state;
+            if (statePtr->flags & TCL_READABLE) {
                 Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
             }
         }
@@ -4594,20 +4595,18 @@ TestChannelCmd(clientData, interp, argc, argv)
             return TCL_ERROR;
         }
         
-        TclFormatInt(buf, chanPtr->refCount);
+        TclFormatInt(buf, statePtr->refCount);
         Tcl_AppendResult(interp, buf, (char *) NULL);
         return TCL_OK;
     }
 
-    if ((cmdName[0] == 'c') &&
-            (strncmp(cmdName, "splice", len) == 0)) {
+    if ((cmdName[0] == 's') && (strncmp(cmdName, "splice", len) == 0)) {
         if (argc != 3) {
-            Tcl_AppendResult(interp, "channel name required",
-                    (char *) NULL);
+            Tcl_AppendResult(interp, "channel name required", (char *) NULL);
             return TCL_ERROR;
         }
-        
-        Tcl_SpliceChannel (chan);
+
+        Tcl_SpliceChannel(chan);
         return TCL_OK;
     }
 
@@ -4617,28 +4616,64 @@ TestChannelCmd(clientData, interp, argc, argv)
                     (char *) NULL);
             return TCL_ERROR;
         }
-        Tcl_AppendResult(interp, chanPtr->typePtr->typeName, (char *) NULL);
+        Tcl_AppendResult(interp, Tcl_ChannelName(chanPtr->typePtr),
+		(char *) NULL);
         return TCL_OK;
     }
-    
+
     if ((cmdName[0] == 'w') && (strncmp(cmdName, "writable", len) == 0)) {
         hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
         if (hTblPtr == (Tcl_HashTable *) NULL) {
             return TCL_OK;
         }
         for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
-                 hPtr != (Tcl_HashEntry *) NULL;
-                 hPtr = Tcl_NextHashEntry(&hSearch)) {
+	     hPtr != (Tcl_HashEntry *) NULL;
+	     hPtr = Tcl_NextHashEntry(&hSearch)) {
             chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
-            if (chanPtr->flags & TCL_WRITABLE) {
+	    statePtr = chanPtr->state;
+            if (statePtr->flags & TCL_WRITABLE) {
                 Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
             }
         }
         return TCL_OK;
     }
 
+    if ((cmdName[0] == 't') && (strncmp(cmdName, "transform", len) == 0)) {
+	/*
+	 * Syntax: transform channel -command command
+	 */
+
+        if (argc != 5) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+		    " transform channelId -command cmd\"", (char *) NULL);
+            return TCL_ERROR;
+        }
+	if (strcmp(argv[3], "-command") != 0) {
+	    Tcl_AppendResult(interp, "bad argument \"", argv[3],
+		    "\": should be \"-command\"", (char *) NULL);
+	    return TCL_ERROR;
+	}
+
+	return TclChannelTransform(interp, chan,
+		Tcl_NewStringObj(argv[4], -1));
+    }
+
+    if ((cmdName[0] == 'u') && (strncmp(cmdName, "unstack", len) == 0)) {
+	/*
+	 * Syntax: unstack channel
+	 */
+
+        if (argc != 3) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+		    " unstack channel\"", (char *) NULL);
+            return TCL_ERROR;
+        }
+	return Tcl_UnstackChannel(interp, chan);
+    }
+
     Tcl_AppendResult(interp, "bad option \"", cmdName, "\": should be ",
-            "info, open, readable, or writable",
+            "cut, clearchannelhandlers, info, isshared, mode, open, "
+	    "readable, splice, writable, transform, unstack",
             (char *) NULL);
     return TCL_ERROR;
 }
@@ -4649,9 +4684,7 @@ TestChannelCmd(clientData, interp, argc, argv)
  * TestChannelEventCmd --
  *
  *	This procedure implements the "testchannelevent" command. It is
- *	used to test the Tcl channel event mechanism. It is present in
- *	this file instead of tclTest.c because it needs access to the
- *	internal structure of the channel.
+ *	used to test the Tcl channel event mechanism.
  *
  * Results:
  *	A standard Tcl result.
@@ -4663,7 +4696,7 @@ TestChannelCmd(clientData, interp, argc, argv)
  */
 
 	/* ARGSUSED */
-static int
+int
 TestChannelEventCmd(dummy, interp, argc, argv)
     ClientData dummy;			/* Not used. */
     Tcl_Interp *interp;			/* Current interpreter. */
@@ -4672,6 +4705,7 @@ TestChannelEventCmd(dummy, interp, argc, argv)
 {
     Tcl_Obj *resultListPtr;
     Channel *chanPtr;
+    ChannelState *statePtr;	/* state info for channel */
     EventScriptRecord *esPtr, *prevEsPtr, *nextEsPtr;
     char *cmd;
     int index, i, mask, len;
@@ -4685,6 +4719,8 @@ TestChannelEventCmd(dummy, interp, argc, argv)
     if (chanPtr == (Channel *) NULL) {
         return TCL_ERROR;
     }
+    statePtr = chanPtr->state;
+
     cmd = argv[2];
     len = strlen(cmd);
     if ((cmd[0] == 'a') && (strncmp(cmd, "add", (unsigned) len) == 0)) {
@@ -4707,8 +4743,8 @@ TestChannelEventCmd(dummy, interp, argc, argv)
 
         esPtr = (EventScriptRecord *) ckalloc((unsigned)
                 sizeof(EventScriptRecord));
-        esPtr->nextPtr = chanPtr->scriptRecordPtr;
-        chanPtr->scriptRecordPtr = esPtr;
+        esPtr->nextPtr = statePtr->scriptRecordPtr;
+        statePtr->scriptRecordPtr = esPtr;
         
         esPtr->chanPtr = chanPtr;
         esPtr->interp = interp;
@@ -4736,9 +4772,9 @@ TestChannelEventCmd(dummy, interp, argc, argv)
                     ": must be nonnegative", (char *) NULL);
             return TCL_ERROR;
         }
-        for (i = 0, esPtr = chanPtr->scriptRecordPtr;
-                 (i < index) && (esPtr != (EventScriptRecord *) NULL);
-                 i++, esPtr = esPtr->nextPtr) {
+        for (i = 0, esPtr = statePtr->scriptRecordPtr;
+	     (i < index) && (esPtr != (EventScriptRecord *) NULL);
+	     i++, esPtr = esPtr->nextPtr) {
 	    /* Empty loop body. */
         }
         if (esPtr == (EventScriptRecord *) NULL) {
@@ -4746,17 +4782,17 @@ TestChannelEventCmd(dummy, interp, argc, argv)
                     ": out of range", (char *) NULL);
             return TCL_ERROR;
         }
-        if (esPtr == chanPtr->scriptRecordPtr) {
-            chanPtr->scriptRecordPtr = esPtr->nextPtr;
+        if (esPtr == statePtr->scriptRecordPtr) {
+            statePtr->scriptRecordPtr = esPtr->nextPtr;
         } else {
-            for (prevEsPtr = chanPtr->scriptRecordPtr;
-                     (prevEsPtr != (EventScriptRecord *) NULL) &&
-                         (prevEsPtr->nextPtr != esPtr);
-                     prevEsPtr = prevEsPtr->nextPtr) {
+            for (prevEsPtr = statePtr->scriptRecordPtr;
+		 (prevEsPtr != (EventScriptRecord *) NULL) &&
+		     (prevEsPtr->nextPtr != esPtr);
+		 prevEsPtr = prevEsPtr->nextPtr) {
                 /* Empty loop body. */
             }
             if (prevEsPtr == (EventScriptRecord *) NULL) {
-                panic("TclTestChannelEventCmd: damaged event script list");
+                panic("TestChannelEventCmd: damaged event script list");
             }
             prevEsPtr->nextPtr = esPtr->nextPtr;
         }
@@ -4775,15 +4811,15 @@ TestChannelEventCmd(dummy, interp, argc, argv)
             return TCL_ERROR;
         }
 	resultListPtr = Tcl_GetObjResult(interp);
-        for (esPtr = chanPtr->scriptRecordPtr;
-                 esPtr != (EventScriptRecord *) NULL;
-                 esPtr = esPtr->nextPtr) {
+        for (esPtr = statePtr->scriptRecordPtr;
+	     esPtr != (EventScriptRecord *) NULL;
+	     esPtr = esPtr->nextPtr) {
 	    if (esPtr->mask) {
  	        Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
 		    (esPtr->mask == TCL_READABLE) ? "readable" : "writable", -1));
  	    } else {
  	        Tcl_ListObjAppendElement(interp, resultListPtr, 
-                    Tcl_NewStringObj("none", -1));
+			Tcl_NewStringObj("none", -1));
 	    }
   	    Tcl_ListObjAppendElement(interp, resultListPtr, esPtr->scriptPtr);
         }
@@ -4797,16 +4833,16 @@ TestChannelEventCmd(dummy, interp, argc, argv)
                     " channelName removeall\"", (char *) NULL);
             return TCL_ERROR;
         }
-        for (esPtr = chanPtr->scriptRecordPtr;
-                 esPtr != (EventScriptRecord *) NULL;
-                 esPtr = nextEsPtr) {
+        for (esPtr = statePtr->scriptRecordPtr;
+	     esPtr != (EventScriptRecord *) NULL;
+	     esPtr = nextEsPtr) {
             nextEsPtr = esPtr->nextPtr;
             Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
                     TclChannelEventScriptInvoker, (ClientData) esPtr);
 	    Tcl_DecrRefCount(esPtr->scriptPtr);
             ckfree((char *) esPtr);
         }
-        chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+        statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
         return TCL_OK;
     }
 
@@ -4824,9 +4860,9 @@ TestChannelEventCmd(dummy, interp, argc, argv)
                     ": must be nonnegative", (char *) NULL);
             return TCL_ERROR;
         }
-        for (i = 0, esPtr = chanPtr->scriptRecordPtr;
-                 (i < index) && (esPtr != (EventScriptRecord *) NULL);
-                 i++, esPtr = esPtr->nextPtr) {
+        for (i = 0, esPtr = statePtr->scriptRecordPtr;
+	     (i < index) && (esPtr != (EventScriptRecord *) NULL);
+	     i++, esPtr = esPtr->nextPtr) {
 	    /* Empty loop body. */
         }
         if (esPtr == (EventScriptRecord *) NULL) {