From 2d7d8bbf34ad1a83c79ac4a426abde4d0d6d673b Mon Sep 17 00:00:00 2001 From: hobbs Date: Thu, 28 Sep 2000 06:38:19 +0000 Subject: 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. --- generic/tcl.decls | 107 +- generic/tcl.h | 54 +- generic/tclDecls.h | 272 +++- generic/tclIO.c | 4146 ++++++++++++++++++++++++++++++------------------- generic/tclIO.h | 123 +- generic/tclIOGT.c | 1359 ++++++++++++++++ generic/tclInt.decls | 10 +- generic/tclIntDecls.h | 16 +- generic/tclStubInit.c | 65 +- generic/tclTest.c | 284 ++-- tests/iogt.test | 940 +++++++++++ win/tclWinChan.c | 8 +- win/tclWinConsole.c | 8 +- win/tclWinPipe.c | 9 +- win/tclWinSerial.c | 26 +- win/tclWinSock.c | 26 +- 16 files changed, 5489 insertions(+), 1964 deletions(-) create mode 100644 generic/tclIOGT.c create mode 100644 tests/iogt.test 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 + /* * 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 , 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 (interest) { - (pt->typePtr->watchProc) (pt->instanceData, 0); - } - - /* - * 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. - */ + if ((mask & TCL_WRITABLE) != 0) { + CopyState *csPtr; - chanPtr->supercedes = pt->supercedes; + csPtr = statePtr->csPtr; + statePtr->csPtr = (CopyState*) NULL; - 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. - * - * - The information about encoding and eol-translation is taken - * without change. There is no need to fiddle with - * refCount et. al. + * 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. * - * 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. - */ - - /* 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 */ - - /* pt->inputTranslation, take it as is */ - /* pt->outputTranslation, take it as is */ - - /* - * No special EOF character, that condition is determined by the - * old channel + * 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->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 */ + 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->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; + statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead; + prevChanPtr->inQueueHead = statePtr->inQueueHead; - /* 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; + + /* + * This operation should occur at the top of a channel stack. + */ - if (chanPtr->supercedes != (Channel*) NULL) { + 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. - */ - - 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 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. - */ + if (statePtr->flags & TCL_WRITABLE) { + CopyState* csPtr; - saveEncoding = chanDownPtr->encoding; - saveInputEncodingState = chanDownPtr->inputEncodingState; - saveInputEncodingFlags = chanDownPtr->inputEncodingFlags; - saveOutputEncodingState = chanDownPtr->outputEncodingState; - saveOutputEncodingFlags = chanDownPtr->outputEncodingFlags; + csPtr = statePtr->csPtr; + statePtr->csPtr = (CopyState*) NULL; - 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 , 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,19 +3836,140 @@ Tcl_Read(chan, dst, bytesToRead) } /* - *--------------------------------------------------------------------------- - * - * Tcl_ReadChars -- + *---------------------------------------------------------------------- * - * Reads from the channel until the requested number of characters - * have been seen, EOF is seen, or the channel would block. EOL - * and EOF translation is done. If reading binary data, the raw - * bytes are wrapped in a Tcl byte array object. Otherwise, the raw - * bytes are converted to UTF-8 using the channel's current encoding - * and stored in a Tcl string object. + * Tcl_ReadRaw -- * - * Results: - * The number of characters read, or -1 on error. Use Tcl_GetErrno() + * 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 -- + * + * Reads from the channel until the requested number of characters + * have been seen, EOF is seen, or the channel would block. EOL + * and EOF translation is done. If reading binary data, the raw + * bytes are wrapped in a Tcl byte array object. Otherwise, the raw + * bytes are converted to UTF-8 using the channel's current encoding + * and stored in a Tcl string object. + * + * Results: + * The number of characters read, or -1 on error. Use Tcl_GetErrno() * to retrieve the error code for the error that occurred. * * Side effects: @@ -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); + } + + /* + * 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 = 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)) { @@ -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. + */ + + chanPtr = statePtr->topChanPtr; + + /* + * If we are in the middle of a background copy, use the saved flags. */ - if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR; + 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; - /* Walk all channels in a stack ! and notify them in order. + /* + * 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 (chanPtr != (Channel *) NULL) { - /* - * Preserve the channel struct in case the script closes it. - */ - - Tcl_Preserve((ClientData) channel); + while (mask && (chanPtr->upChanPtr != ((Channel*) NULL))) { + upChanPtr = chanPtr->upChanPtr; + upTypePtr = upChanPtr->typePtr; - /* - * 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 ((Tcl_ChannelVersion(upTypePtr) == TCL_CHANNEL_VERSION_2) && + (Tcl_ChannelHandlerProc(upTypePtr) != + ((Tcl_DriverHandlerProc *) NULL))) { - if ((chanPtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) { + 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) { + /* + * 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; } @@ -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,20 +7884,66 @@ 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); } /* *---------------------------------------------------------------------- * - * SetBlockMode -- + * StackSetBlockMode -- * - * This function sets the blocking mode for a channel and updates - * the state flags. + * 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 + * the state flags. * * Results: * A standard Tcl result. @@ -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 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) { diff --git a/tests/iogt.test b/tests/iogt.test new file mode 100644 index 0000000..ebb0ab6 --- /dev/null +++ b/tests/iogt.test @@ -0,0 +1,940 @@ +# -*- tcl -*- +# Commands covered: transform, and stacking in general +# +# This file contains a collection of tests for Giot +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# +# Copyright (c) 2000 Ajuba Solutions. +# Copyright (c) 2000 Andreas Kupries. +# All rights reserved. +# +# RCS: @(#) $Id: iogt.test,v 1.2 2000/09/28 06:38:22 hobbs Exp $ + + +if {[lsearch [namespace children] ::tcltest] == -1} { + package require tcltest + namespace import -force ::tcltest::* +} + +if {[info commands testchannel] == ""} { + puts "Skipping io tests. This application does not seem to have the" + puts "testchannel command that is needed to run these tests." + return +} + +::tcltest::saveState + +#::tcltest::makeFile contents name + +::tcltest::makeFile {abcdefghijklmnopqrstuvwxyz0123456789,./?><;'\|":[]\}\{`~!@#$%^&*()_+-=} dummy + +# " capture coloring of quotes + +::tcltest::makeFile {} dummyout + +::tcltest::makeFile { +#!/usr/local/bin/tclsh +# -*- tcl -*- +# echo server +# +# arguments, options: port to listen on for connections. +# delay till echo of first block +# delay between blocks +# blocksize ... + +set port [lindex $argv 0] +set fdelay [lindex $argv 1] +set idelay [lindex $argv 2] +set bsizes [lrange $argv 3 end] +set c 0 + +proc newconn {sock rhost rport} { + global c fdelay + incr c + + #puts stdout "C $sock $rhost $rport / $fdelay" ; flush stdout + + upvar #0 c$c conn + set conn(after) {} + set conn(state) 0 + set conn(size) 0 + set conn(data) "" + set conn(delay) $fdelay + + fileevent $sock readable [list echoGet $c $sock] + fconfigure $sock -translation binary -buffering none -blocking 0 +} + +proc echoGet {c sock} { + global fdelay + upvar #0 c$c conn + + if {[eof $sock]} { + # one-shot echo + exit + } + + append conn(data) [read $sock] + + #puts stdout "G $c $sock $conn(data) <<$conn(data)>>" ; flush stdout + + if {$conn(after) == {}} { + set conn(after) [after $conn(delay) [list echoPut $c $sock]] + } +} + +proc echoPut {c sock} { + global idelay fdelay bsizes + upvar #0 c$c conn + + if {[string length $conn(data)] == 0} { + #puts stdout "C $c $sock" ; flush stdout + # auto terminate + close $sock + exit + #set conn(delay) $fdelay + return + } + + + set conn(delay) $idelay + + set n [lindex $bsizes $conn(size)] + + #puts stdout "P $c $sock $n >>" ; flush stdout + + #puts __________________________________________ + #parray conn + #puts n=<$n> + + + if {[string length $conn(data)] >= $n} { + puts -nonewline $sock [string range $conn(data) 0 $n] + set conn(data) [string range $conn(data) [incr n] end] + } + + incr conn(size) + if {$conn(size) >= [llength $bsizes]} { + set conn(size) [expr {[llength $bsizes]-1}] + } + + set conn(after) [after $conn(delay) [list echoPut $c $sock]] +} + +#fileevent stdin readable {exit ;#cut} + +# main +socket -server newconn $port +vwait forever +} __echo_srv__.tcl + + +######################################################################## + +proc fevent {fdelay idelay blocks script data} { + # start and initialize an echo server, prepare data + # transmission, then hand over to the test script. + # this has to start real transmission via 'flush'. + # The server is stopped after completion of the test. + + # fixed port, not so good. lets hope for the best, for now. + set port 4000 + + eval exec tclsh __echo_srv__.tcl \ + $port $fdelay $idelay $blocks >@stdout & + + after 500 + + #puts stdout "> $port" ; flush stdout + + set sk [socket localhost $port] + fconfigure $sk \ + -blocking 0 \ + -buffering full \ + -buffersize [expr {10+[llength $data]}] + + puts -nonewline $sk $data + + # The channel is prepared to go off. + + #puts stdout ">>>>>" ; flush stdout + + uplevel #0 set sock $sk + set res [uplevel #0 $script] + + catch {close $sk} + return $res +} + +# -------------------------------------------------------------- +# utility transformations ... + +proc id {op data} { + switch -- $op { + create/write - + create/read - + delete/write - + delete/read - + clear_read {;#ignore} + flush/write - + flush/read - + write - + read { + return $data + } + query/maxRead {return -1} + } +} + +proc id_optrail {var op data} { + upvar #0 $var trail + + lappend trail $op + + switch -- $op { + create/write - create/read - + delete/write - delete/read - + flush/read - + clear/read { #ignore } + flush/write - + write - + read { + return $data + } + query/maxRead { + return -1 + } + default { + lappend trail "error $op" + error $op + } + } +} + + +proc id_fulltrail {var op data} { + upvar #0 $var trail + + #puts stdout ">> $var $op $data" ; flush stdout + + switch -- $op { + create/write - create/read - + delete/write - delete/read - + clear_read { + set res *ignored* + } + flush/write - flush/read - + write - + read { + set res $data + } + query/maxRead { + set res -1 + } + } + + #catch {puts stdout "\t>* $res" ; flush stdout} + #catch {puts stdout "x$res"} msg + + lappend trail [list $op $data $res] + return $res +} + +proc counter {var op data} { + upvar #0 $var n + + switch -- $op { + create/write - create/read - + delete/write - delete/read - + clear_read {;#ignore} + flush/write - flush/read {return {}} + write { + return $data + } + read { + if {$n > 0} { + incr n -[string length $data] + if {$n < 0} { + set n 0 + } + } + return $data + } + query/maxRead { + return $n + } + } +} + + +proc counter_audit {var vtrail op data} { + upvar #0 $var n $vtrail trail + + switch -- $op { + create/write - create/read - + delete/write - delete/read - + clear_read { + set res {} + } + flush/write - flush/read { + set res {} + } + write { + set res $data + } + read { + if {$n > 0} { + incr n -[string length $data] + if {$n < 0} { + set n 0 + } + } + set res $data + } + query/maxRead { + set res $n + } + } + + lappend trail [list counter:$op $data $res] + return $res +} + + +proc rblocks {var vtrail n op data} { + upvar #0 $var buf $vtrail trail + + set res {} + + switch -- $op { + create/write - create/read - + delete/write - delete/read - + clear_read { + set buf {} + } + flush/write { + } + flush/read { + set res $buf + set buf {} + } + write { + set data + } + read { + append buf $data + + set b [expr {$n * ([string length $buf] / $n)}] + + append op " $n [string length $buf] :- $b" + + set res [string range $buf 0 [incr b -1]] + set buf [string range $buf [incr b] end] + #return $res + } + query/maxRead { + set res -1 + } + } + + lappend trail [list rblock | $op $data $res | $buf] + return $res +} + + +# -------------------------------------------------------------- +# ... and convenience procedures to stack them + +proc identity {-attach channel} { + testchannel transform $channel -command id +} + +proc audit_ops {var -attach channel} { + testchannel transform $channel -command [list id_optrail $var] +} + +proc audit_flow {var -attach channel} { + testchannel transform $channel -command [list id_fulltrail $var] +} + +proc stopafter {var n -attach channel} { + upvar #0 $var vn + set vn $n + testchannel transform $channel -command [list counter $var] +} + +proc stopafter_audit {var trail n -attach channel} { + upvar #0 $var vn + set vn $n + testchannel transform $channel -command [list counter_audit $var $trail] +} + +proc rblocks_t {var trail n -attach channel} { + testchannel transform $channel -command [list rblocks $var $trail $n] +} + +# -------------------------------------------------------------- +# serialize an array, with keys in sorted order. + +proc array_sget {v} { + upvar $v a + + set res [list] + foreach n [lsort [array names a]] { + lappend res $n $a($n) + } + set res +} + +proc asort {alist} { + # sort a list of key/value pairs by key, removes duplicates too. + + array set a $alist + array_sget a +} + +######################################################################## + + +test iogt-1.1 {stack/unstack} { + set fh [open dummy r] + identity -attach $fh + testchannel unstack $fh + close $fh +} {} + +test iogt-1.2 {stack/close} { + set fh [open dummy r] + identity -attach $fh + close $fh +} {} + +test iogt-1.3 {stack/unstack, configuration, options} { + set fh [open dummy r] + set ca [asort [fconfigure $fh]] + identity -attach $fh + set cb [asort [fconfigure $fh]] + testchannel unstack $fh + set cc [asort [fconfigure $fh]] + close $fh + + # With this system none of the buffering, translation and + # encoding option may change their values with channels + # stacked upon each other or not. + + # cb == ca == cc + + list [string equal $ca $cb] [string equal $cb $cc] [string equal $ca $cc] +} {1 1 1} + +test iogt-1.4 {stack/unstack, configuration} { + set fh [open dummy r] + set ca [asort [fconfigure $fh]] + identity -attach $fh + fconfigure $fh \ + -buffering line \ + -translation cr \ + -encoding shiftjis + testchannel unstack $fh + set cc [asort [fconfigure $fh]] + + set res [list \ + [string equal $ca $cc] \ + [fconfigure $fh -buffering] \ + [fconfigure $fh -translation] \ + [fconfigure $fh -encoding] \ + ] + + close $fh + set res +} {0 line cr shiftjis} + +test iogt-2.0 {basic I/O going through transform} { + set fin [open dummy r] + set fout [open dummyout w] + + identity -attach $fin + identity -attach $fout + + fcopy $fin $fout + + close $fin + close $fout + + set fin [open dummy r] + set fout [open dummyout r] + + set res [string equal [set in [read $fin]] [set out [read $fout]]] + lappend res [string length $in] [string length $out] + + close $fin + close $fout + + set res +} {1 71 71} + + +test iogt-2.1 {basic I/O, operation trail} {unixOnly} { + set fin [open dummy r] + set fout [open dummyout w] + + set ain [list] ; set aout [list] + audit_ops ain -attach $fin + audit_ops aout -attach $fout + + fconfigure $fin -buffersize 10 + fconfigure $fout -buffersize 5 + + fcopy $fin $fout + + close $fin + close $fout + + set res "[join $ain \n]\n--------\n[join $aout \n]" +} {create/read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +read +query/maxRead +flush/read +query/maxRead +delete/read +-------- +create/write +write +write +write +write +write +write +write +write +flush/write +delete/write} + +test iogt-2.2 {basic I/O, data trail} {unixOnly} { + set fin [open dummy r] + set fout [open dummyout w] + + set ain [list] ; set aout [list] + audit_flow ain -attach $fin + audit_flow aout -attach $fout + + fconfigure $fin -buffersize 10 + fconfigure $fout -buffersize 5 + + fcopy $fin $fout + + close $fin + close $fout + + set res "[join $ain \n]\n--------\n[join $aout \n]" +} {create/read {} *ignored* +query/maxRead {} -1 +read abcdefghij abcdefghij +query/maxRead {} -1 +read klmnopqrst klmnopqrst +query/maxRead {} -1 +read uvwxyz0123 uvwxyz0123 +query/maxRead {} -1 +read 456789,./? 456789,./? +query/maxRead {} -1 +read {><;'\|":[]} {><;'\|":[]} +query/maxRead {} -1 +read {\}\{`~!@#$} {\}\{`~!@#$} +query/maxRead {} -1 +read %^&*()_+-= %^&*()_+-= +query/maxRead {} -1 +read { +} { +} +query/maxRead {} -1 +flush/read {} {} +query/maxRead {} -1 +delete/read {} *ignored* +-------- +create/write {} *ignored* +write abcdefghij abcdefghij +write klmnopqrst klmnopqrst +write uvwxyz0123 uvwxyz0123 +write 456789,./? 456789,./? +write {><;'\|":[]} {><;'\|":[]} +write {\}\{`~!@#$} {\}\{`~!@#$} +write %^&*()_+-= %^&*()_+-= +write { +} { +} +flush/write {} {} +delete/write {} *ignored*} + + +test iogt-2.3 {basic I/O, mixed trail} {unixOnly} { + set fin [open dummy r] + set fout [open dummyout w] + + set trail [list] + audit_flow trail -attach $fin + audit_flow trail -attach $fout + + fconfigure $fin -buffersize 20 + fconfigure $fout -buffersize 10 + + fcopy $fin $fout + + close $fin + close $fout + + join $trail \n +} {create/read {} *ignored* +create/write {} *ignored* +query/maxRead {} -1 +read abcdefghijklmnopqrst abcdefghijklmnopqrst +write abcdefghij abcdefghij +write klmnopqrst klmnopqrst +query/maxRead {} -1 +read uvwxyz0123456789,./? uvwxyz0123456789,./? +write uvwxyz0123 uvwxyz0123 +write 456789,./? 456789,./? +query/maxRead {} -1 +read {><;'\|":[]\}\{`~!@#$} {><;'\|":[]\}\{`~!@#$} +write {><;'\|":[]} {><;'\|":[]} +write {\}\{`~!@#$} {\}\{`~!@#$} +query/maxRead {} -1 +read {%^&*()_+-= +} {%^&*()_+-= +} +query/maxRead {} -1 +flush/read {} {} +write %^&*()_+-= %^&*()_+-= +write { +} { +} +query/maxRead {} -1 +delete/read {} *ignored* +flush/write {} {} +delete/write {} *ignored*} + + +test iogt-3.0 {Tcl_Channel valid after stack/unstack, fevent handling} \ + {unknownFailure} { + # This test to check the validity of aquired Tcl_Channel references is + # not possible because even a backgrounded fcopy will immediately start + # to copy data, without waiting for the event loop. This is done only in + # case of an underflow on the read size!. So stacking transforms after the + # fcopy will miss information, or are not used at all. + # + # I was able to circumvent this by using the echo.tcl server with a big + # delay, causing the fcopy to underflow immediately. + + proc DoneCopy {n {err {}}} { + global copy ; set copy 1 + } + + set fin [open dummy r] + + fevent 1000 500 {20 20 20 10 1 1} { + close $fin + + set fout [open dummyout w] + + flush $sock ; # now, or fcopy will error us out + # But the 1 second delay should be enough to + # initialize everything else here. + + fcopy $sock $fout -command DoneCopy + + # transform after fcopy got its handles ! + # They should be still valid for fcopy. + + set trail [list] + audit_ops trail -attach $fout + + vwait copy + } [read $fin] ; # {} + + close $fout + + rename DoneCopy {} + + # Check result of copy. + + set fin [open dummy r] + set fout [open dummyout r] + + set res [string equal [read $fin] [read $fout]] + + close $fin + close $fout + + list $res $trail +} {1 {create/write create/read write flush/write flush/read delete/write delete/read}} + + +test iogt-4.0 {fileevent readable, after transform} {unknownFailure} { + set fin [open dummy r] + set data [read $fin] + close $fin + + set trail [list] + set got [list] + + proc Done {args} { + global stop + set stop 1 + } + + proc Get {sock} { + global trail got + if {[eof $sock]} { + Done + lappend trail "xxxxxxxxxxxxx" + close $sock + return + } + lappend trail "vvvvvvvvvvvvv" + lappend trail "\tgot: [lappend got "\[\[[read $sock]\]\]"]" + lappend trail "=============" + #puts stdout $__ ; flush stdout + #read $sock + } + + fevent 1000 500 {20 20 20 10 1} { + audit_flow trail -attach $sock + rblocks_t rbuf trail 23 -attach $sock + + fileevent $sock readable [list Get $sock] + + flush $sock ; # now, or fcopy will error us out + # But the 1 second delay should be enough to + # initialize everything else here. + + vwait stop + } $data + + + rename Done {} + rename Get {} + + join [list [join $got \n] ~~~~~~~~ [join $trail \n]] \n +} {[[]] +[[abcdefghijklmnopqrstuvw]] +[[xyz0123456789,./?><;'\|]] +[[]] +[[]] +[[":[]\}\{`~!@#$%^&*()]] +[[]] +~~~~~~~~ +create/write {} *ignored* +create/read {} *ignored* +rblock | create/write {} {} | {} +rblock | create/read {} {} | {} +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | {} +query/maxRead {} -1 +read abcdefghijklmnopqrstu abcdefghijklmnopqrstu +query/maxRead {} -1 +rblock | {read 23 21 :- 0} abcdefghijklmnopqrstu {} | abcdefghijklmnopqrstu +rblock | query/maxRead {} -1 | abcdefghijklmnopqrstu +query/maxRead {} -1 + got: {[[]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | abcdefghijklmnopqrstu +query/maxRead {} -1 +read vwxyz0123456789,./?>< vwxyz0123456789,./?>< +query/maxRead {} -1 +rblock | {read 23 42 :- 23} vwxyz0123456789,./?>< abcdefghijklmnopqrstuvw | xyz0123456789,./?>< +rblock | query/maxRead {} -1 | xyz0123456789,./?>< +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | xyz0123456789,./?>< +query/maxRead {} -1 +read {;'\|":[]\}\{`~!@#$%^&} {;'\|":[]\}\{`~!@#$%^&} +query/maxRead {} -1 +rblock | {read 23 40 :- 23} {;'\|":[]\}\{`~!@#$%^&} {xyz0123456789,./?><;'\|} | {":[]\}\{`~!@#$%^&} +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&} +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} {[[xyz0123456789,./?><;'\|]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&} +query/maxRead {} -1 +read *( *( +query/maxRead {} -1 +rblock | {read 23 19 :- 0} *( {} | {":[]\}\{`~!@#$%^&*(} +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&*(} +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} {[[xyz0123456789,./?><;'\|]]} {[[]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&*(} +query/maxRead {} -1 +read ) ) +query/maxRead {} -1 +rblock | {read 23 20 :- 0} ) {} | {":[]\}\{`~!@#$%^&*()} +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&*()} +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} {[[xyz0123456789,./?><;'\|]]} {[[]]} {[[]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | {":[]\}\{`~!@#$%^&*()} +query/maxRead {} -1 +flush/read {} {} +rblock | flush/read {} {":[]\}\{`~!@#$%^&*()} | {} +rblock | query/maxRead {} -1 | {} +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} {[[xyz0123456789,./?><;'\|]]} {[[]]} {[[]]} {[[":[]\}\{`~!@#$%^&*()]]} +============= +vvvvvvvvvvvvv +rblock | query/maxRead {} -1 | {} +query/maxRead {} -1 + got: {[[]]} {[[abcdefghijklmnopqrstuvw]]} {[[xyz0123456789,./?><;'\|]]} {[[]]} {[[]]} {[[":[]\}\{`~!@#$%^&*()]]} {[[]]} +xxxxxxxxxxxxx +rblock | flush/write {} {} | {} +rblock | delete/write {} {} | {} +rblock | delete/read {} {} | {} +flush/write {} {} +delete/write {} *ignored* +delete/read {} *ignored*} ; # catch unescaped quote " + + +test iogt-5.0 {EOF simulation} {unknownFailure} { + set fin [open dummy r] + set fout [open dummyout w] + + set trail [list] + + audit_flow trail -attach $fin + stopafter_audit d trail 20 -attach $fin + audit_flow trail -attach $fout + + fconfigure $fin -buffersize 20 + fconfigure $fout -buffersize 10 + + fcopy $fin $fout + testchannel unstack $fin + + # now copy the rest in the channel + lappend trail {**after unstack**} + + fcopy $fin $fout + + close $fin + close $fout + + join $trail \n +} {create/read {} *ignored* +counter:create/read {} {} +create/write {} *ignored* +counter:query/maxRead {} 20 +query/maxRead {} -1 +read {abcdefghijklmnopqrstuvwxyz0123456789,./?><;'\|":[]\}\{`~!@#$%^&*()_+-= +} {abcdefghijklmnopqrstuvwxyz0123456789,./?><;'\|":[]\}\{`~!@#$%^&*()_+-= +} +query/maxRead {} -1 +flush/read {} {} +counter:read abcdefghijklmnopqrst abcdefghijklmnopqrst +write abcdefghij abcdefghij +write klmnopqrst klmnopqrst +counter:query/maxRead {} 0 +counter:flush/read {} {} +counter:delete/read {} {} +**after unstack** +query/maxRead {} -1 +write uvwxyz0123 uvwxyz0123 +write 456789,./? 456789,./? +write {><;'\|":[]} {><;'\|":[]} +write {\}\{`~!@#$} {\}\{`~!@#$} +write %^&*()_+-= %^&*()_+-= +write { +} { +} +query/maxRead {} -1 +delete/read {} *ignored* +flush/write {} {} +delete/write {} *ignored*} + + + + + +proc constX {op data} { + # replace anything coming in with a same-length string of x'es. + switch -- $op { + create/write - create/read - + delete/write - delete/read - + clear_read {;#ignore} + flush/write - flush/read - + write - + read { + return [string repeat x [string length $data]] + } + query/maxRead {return -1} + } +} + +proc constx {-attach channel} { + testchannel transform $channel -command constX +} + +test iogt-6.0 {Push back} { + set f [open dummy r] + + # contents of dummy = "abcdefghi..." + read $f 3 ; # skip behind "abc" + + constx -attach $f + + # expect to get "xxx" from the transform because + # of unread "def" input to transform which returns "xxx". + # + # Actually the IO layer pre-read the whole file and will + # read "def" directly from the buffer without bothering + # to consult the newly stacked transformation. This is + # wrong. + + set res [read $f 3] + close $f + set res +} {xxx} + +test iogt-6.1 {Push back and up} {knownBug} { + set f [open dummy r] + + # contents of dummy = "abcdefghi..." + read $f 3 ; # skip behind "abc" + + constx -attach $f + set res [read $f 3] + + testchannel unstack $f + append res [read $f 3] + close $f + set res +} {xxxghi} + + +# cleanup +foreach file [list dummy dummyout __echo_srv__.tcl] { + ::tcltest::removeFile $file +} +::tcltest::restoreState +::tcltest::cleanupTests +return diff --git a/win/tclWinChan.c b/win/tclWinChan.c index f40d361..d2f0fa1 100644 --- a/win/tclWinChan.c +++ b/win/tclWinChan.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclWinChan.c,v 1.11 2000/07/18 02:16:31 davidg Exp $ + * RCS: @(#) $Id: tclWinChan.c,v 1.12 2000/09/28 06:38:23 hobbs Exp $ */ #include "tclWinInt.h" @@ -101,7 +101,7 @@ static void FileWatchProc _ANSI_ARGS_((ClientData instanceData, static Tcl_ChannelType fileChannelType = { "file", /* Type name. */ - FileBlockProc, /* Set blocking or non-blocking mode.*/ + TCL_CHANNEL_VERSION_2, /* v2 channel */ FileCloseProc, /* Close proc. */ FileInputProc, /* Input proc. */ FileOutputProc, /* Output proc. */ @@ -110,6 +110,10 @@ static Tcl_ChannelType fileChannelType = { NULL, /* Get option proc. */ FileWatchProc, /* Set up the notifier to watch the channel. */ FileGetHandleProc, /* Get an OS handle from channel. */ + NULL, /* close2proc. */ + FileBlockProc, /* Set blocking or non-blocking mode.*/ + NULL, /* flush proc. */ + NULL, /* handler proc. */ }; diff --git a/win/tclWinConsole.c b/win/tclWinConsole.c index d84d48d..d15f052 100644 --- a/win/tclWinConsole.c +++ b/win/tclWinConsole.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclWinConsole.c,v 1.4 2000/05/22 23:54:45 hobbs Exp $ + * RCS: @(#) $Id: tclWinConsole.c,v 1.5 2000/09/28 06:38:23 hobbs Exp $ */ #include "tclWinInt.h" @@ -162,7 +162,7 @@ static int WaitForRead(ConsoleInfo *infoPtr, int blocking); static Tcl_ChannelType consoleChannelType = { "console", /* Type name. */ - ConsoleBlockModeProc, /* Set blocking or non-blocking mode.*/ + TCL_CHANNEL_VERSION_2, /* v2 channel */ ConsoleCloseProc, /* Close proc. */ ConsoleInputProc, /* Input proc. */ ConsoleOutputProc, /* Output proc. */ @@ -171,6 +171,10 @@ static Tcl_ChannelType consoleChannelType = { NULL, /* Get option proc. */ ConsoleWatchProc, /* Set up notifier to watch the channel. */ ConsoleGetHandleProc, /* Get an OS handle from channel. */ + NULL, /* close2proc. */ + ConsoleBlockModeProc, /* Set blocking or non-blocking mode.*/ + NULL, /* flush proc. */ + NULL, /* handler proc. */ }; /* diff --git a/win/tclWinPipe.c b/win/tclWinPipe.c index 92d6613..c6d2b5c 100644 --- a/win/tclWinPipe.c +++ b/win/tclWinPipe.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclWinPipe.c,v 1.14 2000/09/08 03:59:56 davidg Exp $ + * RCS: @(#) $Id: tclWinPipe.c,v 1.15 2000/09/28 06:38:23 hobbs Exp $ */ #include "tclWinInt.h" @@ -211,7 +211,7 @@ static int WaitForRead(PipeInfo *infoPtr, int blocking); static Tcl_ChannelType pipeChannelType = { "pipe", /* Type name. */ - PipeBlockModeProc, /* Set blocking or non-blocking mode.*/ + TCL_CHANNEL_VERSION_2, /* v2 channel */ TCL_CLOSE2PROC, /* Close proc. */ PipeInputProc, /* Input proc. */ PipeOutputProc, /* Output proc. */ @@ -220,7 +220,10 @@ static Tcl_ChannelType pipeChannelType = { NULL, /* Get option proc. */ PipeWatchProc, /* Set up notifier to watch the channel. */ PipeGetHandleProc, /* Get an OS handle from channel. */ - PipeClose2Proc + PipeClose2Proc, /* close2proc */ + PipeBlockModeProc, /* Set blocking or non-blocking mode.*/ + NULL, /* flush proc. */ + NULL, /* handler proc. */ }; /* diff --git a/win/tclWinSerial.c b/win/tclWinSerial.c index 500aff8..da07df1 100644 --- a/win/tclWinSerial.c +++ b/win/tclWinSerial.c @@ -10,7 +10,7 @@ * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * Changes by Rolf.Schroedter@dlr.de June 25-27, 1999 * - * RCS: @(#) $Id: tclWinSerial.c,v 1.10 2000/05/22 23:54:57 hobbs Exp $ + * RCS: @(#) $Id: tclWinSerial.c,v 1.11 2000/09/28 06:38:23 hobbs Exp $ */ #include "tclWinInt.h" @@ -154,16 +154,20 @@ static int SerialSetOptionProc _ANSI_ARGS_((ClientData instanceData, */ static Tcl_ChannelType serialChannelType = { - "serial", /* Type name. */ - SerialBlockProc, /* Set blocking or non-blocking mode.*/ - SerialCloseProc, /* Close proc. */ - SerialInputProc, /* Input proc. */ - SerialOutputProc, /* Output proc. */ - NULL, /* Seek proc. */ - SerialSetOptionProc, /* Set option proc. */ - SerialGetOptionProc, /* Get option proc. */ - SerialWatchProc, /* Set up notifier to watch the channel. */ - SerialGetHandleProc, /* Get an OS handle from channel. */ + "serial", /* Type name. */ + TCL_CHANNEL_VERSION_2, /* v2 channel */ + SerialCloseProc, /* Close proc. */ + SerialInputProc, /* Input proc. */ + SerialOutputProc, /* Output proc. */ + NULL, /* Seek proc. */ + SerialSetOptionProc, /* Set option proc. */ + SerialGetOptionProc, /* Get option proc. */ + SerialWatchProc, /* Set up notifier to watch the channel. */ + SerialGetHandleProc, /* Get an OS handle from channel. */ + NULL, /* close2proc. */ + SerialBlockProc, /* Set blocking or non-blocking mode.*/ + NULL, /* flush proc. */ + NULL, /* handler proc. */ }; /* diff --git a/win/tclWinSock.c b/win/tclWinSock.c index 957f72c..92e88ef 100644 --- a/win/tclWinSock.c +++ b/win/tclWinSock.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: tclWinSock.c,v 1.18 1999/12/09 14:44:11 hobbs Exp $ + * RCS: @(#) $Id: tclWinSock.c,v 1.19 2000/09/28 06:38:23 hobbs Exp $ */ #include "tclWinInt.h" @@ -215,16 +215,20 @@ static DWORD WINAPI SocketThread _ANSI_ARGS_((LPVOID arg)); */ static Tcl_ChannelType tcpChannelType = { - "tcp", /* Type name. */ - TcpBlockProc, /* Set socket into blocking/non-blocking mode. */ - TcpCloseProc, /* Close proc. */ - TcpInputProc, /* Input proc. */ - TcpOutputProc, /* Output proc. */ - NULL, /* Seek proc. */ - NULL, /* Set option proc. */ - TcpGetOptionProc, /* Get option proc. */ - TcpWatchProc, /* Initialize notifier to watch this channel. */ - TcpGetHandleProc, /* Get an OS handle from channel. */ + "tcp", /* Type name. */ + TCL_CHANNEL_VERSION_2, /* v2 channel */ + TcpCloseProc, /* Close proc. */ + TcpInputProc, /* Input proc. */ + TcpOutputProc, /* Output proc. */ + NULL, /* Seek proc. */ + NULL, /* Set option proc. */ + TcpGetOptionProc, /* Get option proc. */ + TcpWatchProc, /* Set up notifier to watch this channel. */ + TcpGetHandleProc, /* Get an OS handle from channel. */ + NULL, /* close2proc. */ + TcpBlockProc, /* Set socket into (non-)blocking mode. */ + NULL, /* flush proc. */ + NULL, /* handler proc. */ }; /* -- cgit v0.12