diff options
| -rw-r--r-- | generic/tclIO.c | 2878 |
1 files changed, 1455 insertions, 1423 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c index ca1c868..b41a7b6 100644 --- a/generic/tclIO.c +++ b/generic/tclIO.c @@ -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: tclIO.c,v 1.79 2004/10/06 15:59:23 dgp Exp $ + * RCS: @(#) $Id: tclIO.c,v 1.80 2004/11/09 15:47:26 dkf Exp $ */ #include "tclInt.h" @@ -28,7 +28,6 @@ */ typedef struct ThreadSpecificData { - /* * This variable holds the list of nested ChannelHandlerEventProc * invocations. @@ -40,6 +39,7 @@ typedef struct ThreadSpecificData { * as only one ChannelState exists per set of stacked channels. */ ChannelState *firstCSPtr; + #ifdef oldcode /* * Has a channel exit handler been created yet? @@ -52,6 +52,7 @@ typedef struct ThreadSpecificData { */ int channelEventSourceCreated; #endif + /* * Static variables to hold channels for stdin, stdout and stderr. */ @@ -72,85 +73,81 @@ static Tcl_ThreadDataKey dataKey; static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length)); static void ChannelTimerProc _ANSI_ARGS_(( - ClientData clientData)); + ClientData clientData)); static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr, - int direction)); + 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, - ChannelState *statePtr)); + 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_(( - ChannelState *statePtr, char *result, - int space)); -static int CopyBuffer _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)); -static void CreateScriptRecord _ANSI_ARGS_(( - Tcl_Interp *interp, Channel *chanPtr, - int mask, Tcl_Obj *scriptPtr)); + int mask)); +static void CreateScriptRecord _ANSI_ARGS_((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 int DetachChannel _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Channel chan)); + Channel *chanPtr, int mask)); +static int DetachChannel _ANSI_ARGS_((Tcl_Interp *interp, + Tcl_Channel chan)); static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr, - int discardSavedBuffers)); + int discardSavedBuffers)); static void DiscardOutputQueued _ANSI_ARGS_(( - ChannelState *chanPtr)); + ChannelState *chanPtr)); static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr, - int slen)); + int slen)); static int DoWrite _ANSI_ARGS_((Channel *chanPtr, CONST char *src, - int srcLen)); -static int DoReadChars _ANSI_ARGS_ ((Channel* chan, - Tcl_Obj* objPtr, int toRead, int appendFlag)); -static int DoWriteChars _ANSI_ARGS_ ((Channel* chan, - CONST char* src, int len)); + int srcLen)); +static int DoReadChars _ANSI_ARGS_((Channel *chan, + Tcl_Obj *objPtr, int toRead, int appendFlag)); +static int DoWriteChars _ANSI_ARGS_((Channel *chan, + CONST char *src, int len)); 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 int HaveVersion _ANSI_ARGS_((Tcl_ChannelType *typePtr, - Tcl_ChannelTypeVersion minimumVersion)); + Tcl_ChannelTypeVersion minimumVersion)); static void PeekAhead _ANSI_ARGS_((Channel *chanPtr, - char **dstEndPtr, GetsState *gsPtr)); + char **dstEndPtr, GetsState *gsPtr)); static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr, - Tcl_Obj *objPtr, int charsLeft, - int *offsetPtr)); + Tcl_Obj *objPtr, int charsLeft, int *offsetPtr)); static int ReadChars _ANSI_ARGS_((ChannelState *statePtr, - Tcl_Obj *objPtr, int charsLeft, - int *offsetPtr, int *factorPtr)); + Tcl_Obj *objPtr, int charsLeft, + int *offsetPtr, int *factorPtr)); static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr, - ChannelBuffer *bufPtr, int mustDiscard)); + ChannelBuffer *bufPtr, int mustDiscard)); static int StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr, - int mode)); + 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_((ChannelState *statePtr, - char *dst, CONST char *src, - int *dstLenPtr, int *srcLenPtr)); + 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)); + 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)); /* *--------------------------------------------------------------------------- @@ -207,53 +204,53 @@ TclFinalizeIOSubsystem() ChannelState *statePtr; /* state of channel stack */ for (statePtr = tsdPtr->firstCSPtr; statePtr != (ChannelState *) NULL; - statePtr = nextCSPtr) { - chanPtr = statePtr->topChanPtr; - nextCSPtr = statePtr->nextCSPtr; + statePtr = nextCSPtr) { + chanPtr = statePtr->topChanPtr; + nextCSPtr = statePtr->nextCSPtr; - /* - * Set the channel back into blocking mode to ensure that we wait - * for all data to flush out. - */ - - (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, - "-blocking", "on"); + /* + * Set the channel back into blocking mode to ensure that we wait + * for all data to flush out. + */ + + (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, + "-blocking", "on"); - if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || - (chanPtr == (Channel *) tsdPtr->stdoutChannel) || - (chanPtr == (Channel *) tsdPtr->stderrChannel)) { + if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || + (chanPtr == (Channel *) tsdPtr->stdoutChannel) || + (chanPtr == (Channel *) tsdPtr->stderrChannel)) { - /* - * Decrement the refcount which was earlier artificially bumped - * up to keep the channel from being closed. - */ + /* + * Decrement the refcount which was earlier artificially bumped + * up to keep the channel from being closed. + */ - statePtr->refCount--; - } + statePtr->refCount--; + } - if (statePtr->refCount <= 0) { + if (statePtr->refCount <= 0) { /* - * Close it only if the refcount indicates that the channel is not - * referenced from any interpreter. If it is, that interpreter will - * close the channel when it gets destroyed. - */ + * Close it only if the refcount indicates that the channel is not + * referenced from any interpreter. If it is, that interpreter will + * close the channel when it gets destroyed. + */ - (void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); + (void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); - } else { + } else { - /* - * The refcount is greater than zero, so flush the channel. - */ + /* + * The refcount is greater than zero, so flush the channel. + */ - Tcl_Flush((Tcl_Channel) chanPtr); + Tcl_Flush((Tcl_Channel) chanPtr); + + /* + * Call the device driver to actually close the underlying + * device for this channel. + */ - /* - * Call the device driver to actually close the underlying - * device for this channel. - */ - if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { (chanPtr->typePtr->closeProc)(chanPtr->instanceData, (Tcl_Interp *) NULL); @@ -262,19 +259,18 @@ TclFinalizeIOSubsystem() (Tcl_Interp *) NULL, 0); } - /* - * Finally, we clean up the fields in the channel data structure - * since all of them have been deleted already. We mark the - * channel with CHANNEL_DEAD to prevent any further IO operations - * on it. - */ + /* + * Finally, we clean up the fields in the channel data structure + * since all of them have been deleted already. We mark the + * channel with CHANNEL_DEAD to prevent any further IO operations + * on it. + */ - chanPtr->instanceData = (ClientData) NULL; - statePtr->flags |= CHANNEL_DEAD; - } + chanPtr->instanceData = (ClientData) NULL; + statePtr->flags |= CHANNEL_DEAD; + } } } - /* *---------------------------------------------------------------------- @@ -331,6 +327,7 @@ Tcl_SetStdChannel(channel, type) * *---------------------------------------------------------------------- */ + Tcl_Channel Tcl_GetStdChannel(type) int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ @@ -350,18 +347,18 @@ Tcl_GetStdChannel(type) tsdPtr->stdinInitialized = 1; /* - * Artificially bump the refcount to ensure that the channel - * is only closed on exit. - * - * NOTE: Must only do this if stdinChannel is not NULL. It - * can be NULL in situations where Tcl is unable to connect - * to the standard input. - */ - - if (tsdPtr->stdinChannel != (Tcl_Channel) NULL) { - (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, - tsdPtr->stdinChannel); - } + * Artificially bump the refcount to ensure that the channel + * is only closed on exit. + * + * NOTE: Must only do this if stdinChannel is not NULL. It + * can be NULL in situations where Tcl is unable to connect + * to the standard input. + */ + + if (tsdPtr->stdinChannel != (Tcl_Channel) NULL) { + (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, + tsdPtr->stdinChannel); + } } channel = tsdPtr->stdinChannel; break; @@ -369,10 +366,10 @@ Tcl_GetStdChannel(type) if (!tsdPtr->stdoutInitialized) { tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT); tsdPtr->stdoutInitialized = 1; - if (tsdPtr->stdoutChannel != (Tcl_Channel) NULL) { - (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, - tsdPtr->stdoutChannel); - } + if (tsdPtr->stdoutChannel != (Tcl_Channel) NULL) { + (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, + tsdPtr->stdoutChannel); + } } channel = tsdPtr->stdoutChannel; break; @@ -380,17 +377,16 @@ Tcl_GetStdChannel(type) if (!tsdPtr->stderrInitialized) { tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR); tsdPtr->stderrInitialized = 1; - if (tsdPtr->stderrChannel != (Tcl_Channel) NULL) { - (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, - tsdPtr->stderrChannel); - } + if (tsdPtr->stderrChannel != (Tcl_Channel) NULL) { + (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, + tsdPtr->stderrChannel); + } } channel = tsdPtr->stderrChannel; break; } return channel; } - /* *---------------------------------------------------------------------- @@ -413,11 +409,11 @@ Tcl_GetStdChannel(type) void Tcl_CreateCloseHandler(chan, proc, clientData) Tcl_Channel chan; /* The channel for which to create the - * close callback. */ + * close callback. */ Tcl_CloseProc *proc; /* The callback routine to call when the - * channel will be closed. */ + * channel will be closed. */ ClientData clientData; /* Arbitrary data to pass to the - * close callback. */ + * close callback. */ { ChannelState *statePtr; CloseCallback *cbPtr; @@ -454,28 +450,28 @@ Tcl_CreateCloseHandler(chan, proc, clientData) void Tcl_DeleteCloseHandler(chan, proc, clientData) Tcl_Channel chan; /* The channel for which to cancel the - * close callback. */ + * close callback. */ Tcl_CloseProc *proc; /* The procedure for the callback to - * remove. */ + * remove. */ ClientData clientData; /* The callback data for the callback - * to remove. */ + * to remove. */ { ChannelState *statePtr; CloseCallback *cbPtr, *cbPrevPtr; 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) { - statePtr->closeCbPtr = cbPtr->nextPtr; - } - ckfree((char *) cbPtr); - break; - } else { - cbPrevPtr = cbPtr; - } + cbPtr != (CloseCallback *) NULL; + cbPtr = cbPtr->nextPtr) { + if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) { + if (cbPrevPtr == (CloseCallback *) NULL) { + statePtr->closeCbPtr = cbPtr->nextPtr; + } + ckfree((char *) cbPtr); + break; + } else { + cbPrevPtr = cbPtr; + } } } @@ -508,34 +504,33 @@ GetChannelTable(interp) hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL); if (hTblPtr == (Tcl_HashTable *) NULL) { - hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable)); - Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS); - - (void) Tcl_SetAssocData(interp, "tclIO", - (Tcl_InterpDeleteProc *) DeleteChannelTable, - (ClientData) hTblPtr); - - /* - * If the interpreter is trusted (not "safe"), insert channels - * for stdin, stdout and stderr (possibly creating them in the - * process). - */ - - if (Tcl_IsSafe(interp) == 0) { - stdinChan = Tcl_GetStdChannel(TCL_STDIN); - if (stdinChan != NULL) { - Tcl_RegisterChannel(interp, stdinChan); - } - stdoutChan = Tcl_GetStdChannel(TCL_STDOUT); - if (stdoutChan != NULL) { - Tcl_RegisterChannel(interp, stdoutChan); - } - stderrChan = Tcl_GetStdChannel(TCL_STDERR); - if (stderrChan != NULL) { - Tcl_RegisterChannel(interp, stderrChan); - } - } + hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable)); + Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS); + (void) Tcl_SetAssocData(interp, "tclIO", + (Tcl_InterpDeleteProc *) DeleteChannelTable, + (ClientData) hTblPtr); + + /* + * If the interpreter is trusted (not "safe"), insert channels + * for stdin, stdout and stderr (possibly creating them in the + * process). + */ + + if (Tcl_IsSafe(interp) == 0) { + stdinChan = Tcl_GetStdChannel(TCL_STDIN); + if (stdinChan != NULL) { + Tcl_RegisterChannel(interp, stdinChan); + } + stdoutChan = Tcl_GetStdChannel(TCL_STDOUT); + if (stdoutChan != NULL) { + Tcl_RegisterChannel(interp, stdoutChan); + } + stderrChan = Tcl_GetStdChannel(TCL_STDERR); + if (stderrChan != NULL) { + Tcl_RegisterChannel(interp, stderrChan); + } + } } return hTblPtr; } @@ -573,62 +568,62 @@ DeleteChannelTable(clientData, interp) 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. */ + * registered, to delete the ones that refer + * to the interpreter being deleted. */ /* * Delete all the registered channels - this will close channels whose * refcount reaches zero. */ - + hTblPtr = (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); + chanPtr = (Channel *) Tcl_GetHashValue(hPtr); statePtr = chanPtr->state; - /* - * Remove any fileevents registered in this interpreter. - */ - - 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_DecrRefCount(sPtr->scriptPtr); - ckfree((char *) sPtr); - } else { - prevPtr = sPtr; - } - } - - /* - * Cannot call Tcl_UnregisterChannel because that procedure calls - * Tcl_GetAssocData to get the channel table, which might already - * be inaccessible from the interpreter structure. Instead, we - * emulate the behavior of Tcl_UnregisterChannel directly here. - */ - - Tcl_DeleteHashEntry(hPtr); - statePtr->refCount--; - if (statePtr->refCount <= 0) { - if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { - (void) Tcl_Close(interp, (Tcl_Channel) chanPtr); - } - } + /* + * Remove any fileevents registered in this interpreter. + */ + + 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); + + TclDecrRefCount(sPtr->scriptPtr); + ckfree((char *) sPtr); + } else { + prevPtr = sPtr; + } + } + + /* + * Cannot call Tcl_UnregisterChannel because that procedure calls + * Tcl_GetAssocData to get the channel table, which might already + * be inaccessible from the interpreter structure. Instead, we + * emulate the behavior of Tcl_UnregisterChannel directly here. + */ + + Tcl_DeleteHashEntry(hPtr); + statePtr->refCount--; + if (statePtr->refCount <= 0) { + if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { + (void) Tcl_Close(interp, (Tcl_Channel) chanPtr); + } + } } Tcl_DeleteHashTable(hTblPtr); ckfree((char *) hTblPtr); @@ -664,25 +659,25 @@ CheckForStdChannelsBeingClosed(chan) ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) { - if (statePtr->refCount < 2) { - statePtr->refCount = 0; - tsdPtr->stdinChannel = NULL; - return; - } + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stdinChannel = NULL; + return; + } } else if ((chan == tsdPtr->stdoutChannel) && (tsdPtr->stdoutInitialized)) { - if (statePtr->refCount < 2) { - statePtr->refCount = 0; - tsdPtr->stdoutChannel = NULL; - return; - } + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stdoutChannel = NULL; + return; + } } else if ((chan == tsdPtr->stderrChannel) && (tsdPtr->stderrInitialized)) { - if (statePtr->refCount < 2) { - statePtr->refCount = 0; - tsdPtr->stderrChannel = NULL; - return; - } + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stderrChannel = NULL; + return; + } } } @@ -699,10 +694,11 @@ CheckForStdChannelsBeingClosed(chan) * Returns 1 if true, 0 if false. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ + int Tcl_IsStandardChannel(chan) Tcl_Channel chan; /* Channel to check. */ @@ -710,8 +706,8 @@ Tcl_IsStandardChannel(chan) ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); if ((chan == tsdPtr->stdinChannel) - || (chan == tsdPtr->stdoutChannel) - || (chan == tsdPtr->stderrChannel)) { + || (chan == tsdPtr->stdoutChannel) + || (chan == tsdPtr->stderrChannel)) { return 1; } else { return 0; @@ -740,7 +736,7 @@ void Tcl_RegisterChannel(interp, chan) Tcl_Interp *interp; /* Interpreter in which to add the channel. */ Tcl_Channel chan; /* The channel to add to this interpreter - * channel table. */ + * channel table. */ { Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_HashEntry *hPtr; /* Search variable. */ @@ -753,23 +749,24 @@ Tcl_RegisterChannel(interp, chan) * management of the channel list easier because no manipulation is * necessary during (un)stack operation. */ + chanPtr = ((Channel *) chan)->state->bottomChanPtr; statePtr = chanPtr->state; if (statePtr->channelName == (CONST char *) NULL) { - Tcl_Panic("Tcl_RegisterChannel: channel without name"); + Tcl_Panic("Tcl_RegisterChannel: channel without name"); } if (interp != (Tcl_Interp *) NULL) { - hTblPtr = GetChannelTable(interp); - hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new); - if (new == 0) { - if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) { - return; - } + hTblPtr = GetChannelTable(interp); + hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new); + if (new == 0) { + if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) { + return; + } Tcl_Panic("Tcl_RegisterChannel: duplicate channel names"); - } - Tcl_SetHashValue(hPtr, (ClientData) chanPtr); + } + Tcl_SetHashValue(hPtr, (ClientData) chanPtr); } statePtr->refCount++; } @@ -810,18 +807,17 @@ Tcl_UnregisterChannel(interp, chan) statePtr = ((Channel *) chan)->state->bottomChanPtr->state; if (statePtr->flags & CHANNEL_INCLOSE) { - if (interp != (Tcl_Interp*) NULL) { - Tcl_AppendResult(interp, - "Illegal recursive call to close through close-handler of channel", - (char *) NULL); + if (interp != (Tcl_Interp *) NULL) { + Tcl_AppendResult(interp, "Illegal recursive call to close ", + "through close-handler of channel", (char *) NULL); } return TCL_ERROR; } if (DetachChannel(interp, chan) != TCL_OK) { - return TCL_OK; + return TCL_OK; } - + statePtr = ((Channel *) chan)->state->bottomChanPtr->state; /* @@ -840,18 +836,18 @@ Tcl_UnregisterChannel(interp, chan) if (statePtr->refCount <= 0) { - /* - * Ensure that if there is another buffer, it gets flushed - * whether or not we are doing a background flush. - */ + /* + * Ensure that if there is another buffer, it gets flushed + * whether or not we are doing a background flush. + */ - if ((statePtr->curOutPtr != NULL) && - (statePtr->curOutPtr->nextAdded > - statePtr->curOutPtr->nextRemoved)) { - statePtr->flags |= BUFFER_READY; - } + if ((statePtr->curOutPtr != NULL) && + (statePtr->curOutPtr->nextAdded > + statePtr->curOutPtr->nextRemoved)) { + statePtr->flags |= BUFFER_READY; + } Tcl_Preserve((ClientData)statePtr); - if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { + if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { /* We don't want to re-enter Tcl_Close */ if (!(statePtr->flags & CHANNEL_CLOSED)) { if (Tcl_Close(interp, chan) != TCL_OK) { @@ -860,8 +856,8 @@ Tcl_UnregisterChannel(interp, chan) return TCL_ERROR; } } - } - statePtr->flags |= CHANNEL_CLOSED; + } + statePtr->flags |= CHANNEL_CLOSED; Tcl_Release((ClientData)statePtr); } return TCL_OK; @@ -910,9 +906,9 @@ Tcl_DetachChannel(interp, chan) Tcl_Channel chan; /* Channel to delete. */ { if (Tcl_IsStandardChannel(chan)) { - return TCL_ERROR; + return TCL_ERROR; } - + return DetachChannel(interp, chan); } @@ -956,6 +952,7 @@ DetachChannel(interp, chan) * management of the channel list easier because no manipulation is * necessary during (un)stack operation. */ + chanPtr = ((Channel *) chan)->state->bottomChanPtr; statePtr = chanPtr->state; @@ -980,15 +977,14 @@ DetachChannel(interp, chan) * between several interpreters, or if the channel has async * flushing active. */ - + CleanupChannelHandlers(interp, chanPtr); } statePtr->refCount--; - + return TCL_OK; } - /* *--------------------------------------------------------------------------- @@ -1013,12 +1009,12 @@ DetachChannel(interp, chan) Tcl_Channel Tcl_GetChannel(interp, chanName, modePtr) Tcl_Interp *interp; /* Interpreter in which to find or create - * the channel. */ + * the channel. */ CONST char *chanName; /* The name of the channel. */ int *modePtr; /* Where to store the mode in which the - * channel was opened? Will contain an ORed - * combination of TCL_READABLE and - * TCL_WRITABLE, if non-NULL. */ + * channel was opened? Will contain an ORed + * combination of TCL_READABLE and + * TCL_WRITABLE, if non-NULL. */ { Channel *chanPtr; /* The actual channel. */ Tcl_HashTable *hTblPtr; /* Hash table of channels. */ @@ -1051,9 +1047,9 @@ Tcl_GetChannel(interp, chanName, modePtr) hTblPtr = GetChannelTable(interp); hPtr = Tcl_FindHashEntry(hTblPtr, name); if (hPtr == (Tcl_HashEntry *) NULL) { - Tcl_AppendResult(interp, "can not find channel named \"", - chanName, "\"", (char *) NULL); - return NULL; + Tcl_AppendResult(interp, "can not find channel named \"", + chanName, "\"", (char *) NULL); + return NULL; } /* @@ -1062,12 +1058,13 @@ Tcl_GetChannel(interp, chanName, modePtr) * 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->state->flags & (TCL_READABLE|TCL_WRITABLE)); + *modePtr = (chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE)); } - + return (Tcl_Channel) chanPtr; } @@ -1095,7 +1092,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) CONST char *chanName; /* Name of channel to record. */ ClientData instanceData; /* Instance specific data. */ int mask; /* TCL_READABLE & TCL_WRITABLE to indicate - * if the channel is readable, writable. */ + * if the channel is readable, writable. */ { Channel *chanPtr; /* The channel structure newly created. */ ChannelState *statePtr; /* The stack-level independent state info @@ -1119,12 +1116,13 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) * JH: We could subsequently memset these to 0 to avoid the * numerous assignments to 0/NULL below. */ - chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); + + chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); statePtr = (ChannelState *) ckalloc((unsigned) sizeof(ChannelState)); chanPtr->state = statePtr; - chanPtr->instanceData = instanceData; - chanPtr->typePtr = typePtr; + chanPtr->instanceData = instanceData; + chanPtr->typePtr = typePtr; /* * Set all the bits that are part of the stack-independent state @@ -1133,13 +1131,13 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) if (chanName != (char *) NULL) { char *tmp = ckalloc((unsigned) (strlen(chanName) + 1)); - statePtr->channelName = tmp; - strcpy(tmp, chanName); + statePtr->channelName = tmp; + strcpy(tmp, chanName); } else { - Tcl_Panic("Tcl_CreateChannel: NULL channel name"); + Tcl_Panic("Tcl_CreateChannel: NULL channel name"); } - statePtr->flags = mask; + statePtr->flags = mask; /* * Set the channel to system default encoding. @@ -1187,18 +1185,19 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) statePtr->outputStage = NULL; if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { statePtr->outputStage = (char *) - ckalloc((unsigned) (statePtr->bufSize + 2)); + 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; + chanPtr->inQueueHead = (ChannelBuffer *) NULL; + chanPtr->inQueueTail = (ChannelBuffer *) NULL; /* * Link the channel into the list of all channels; create an on-exit @@ -1208,16 +1207,16 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check. */ - statePtr->nextCSPtr = tsdPtr->firstCSPtr; - tsdPtr->firstCSPtr = statePtr; + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; /* * TIP #10. Mark the current thread as the one managing the new - * channel. Note: 'Tcl_GetCurrentThread' returns sensible - * values even for a non-threaded core. + * channel. Note: 'Tcl_GetCurrentThread' returns sensible + * values even for a non-threaded core. */ - statePtr->managingThread = Tcl_GetCurrentThread (); + statePtr->managingThread = Tcl_GetCurrentThread(); /* * Install this channel in the first empty standard channel slot, if @@ -1227,15 +1226,15 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN); - Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else if ((tsdPtr->stdoutChannel == NULL) && (tsdPtr->stdoutInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT); - Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else if ((tsdPtr->stderrChannel == NULL) && (tsdPtr->stderrInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR); - Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } return (Tcl_Channel) chanPtr; } @@ -1257,7 +1256,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) * * Results: * Returns the new Tcl_Channel, which actually contains the - * saved information about prevChan. + * saved information about prevChan. * * Side effects: * A new channel structure is allocated and linked below @@ -1271,18 +1270,18 @@ 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_ChannelType *typePtr; /* The channel type record for the new - * channel. */ - ClientData instanceData; /* Instance specific data for the new - * channel. */ - int mask; /* TCL_READABLE & TCL_WRITABLE to indicate - * if the channel is readable, writable. */ - Tcl_Channel prevChan; /* The channel structure to replace */ + 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 + * channel. */ + int mask; /* TCL_READABLE & TCL_WRITABLE to indicate + * if the channel is readable, writable. */ + Tcl_Channel prevChan; /* The channel structure to replace */ { - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - Channel *chanPtr, *prevChanPtr; - ChannelState *statePtr; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + Channel *chanPtr, *prevChanPtr; + ChannelState *statePtr; /* * Find the given channel in the list of all channels. @@ -1291,7 +1290,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) * This operation should occur at the top of a channel stack. */ - statePtr = (ChannelState *) tsdPtr->firstCSPtr; + statePtr = (ChannelState *) tsdPtr->firstCSPtr; prevChanPtr = ((Channel *) prevChan)->state->topChanPtr; while (statePtr->topChanPtr != prevChanPtr) { @@ -1301,7 +1300,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) if (statePtr == NULL) { Tcl_AppendResult(interp, "couldn't find state for channel \"", Tcl_GetChannelName(prevChan), "\"", (char *) NULL); - return (Tcl_Channel) NULL; + return (Tcl_Channel) NULL; } /* @@ -1321,7 +1320,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) Tcl_AppendResult(interp, "reading and writing both disallowed for channel \"", Tcl_GetChannelName(prevChan), "\"", (char *) NULL); - return (Tcl_Channel) NULL; + return (Tcl_Channel) NULL; } /* @@ -1332,10 +1331,10 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) */ if ((mask & TCL_WRITABLE) != 0) { - CopyState *csPtr; + CopyState *csPtr; - csPtr = statePtr->csPtr; - statePtr->csPtr = (CopyState*) NULL; + csPtr = statePtr->csPtr; + statePtr->csPtr = (CopyState *) NULL; if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) { statePtr->csPtr = csPtr; @@ -1363,21 +1362,21 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) */ if (((mask & TCL_READABLE) != 0) && - (statePtr->inQueueHead != (ChannelBuffer*) NULL)) { - /* - * Remark: It is possible that the channel buffers contain data from - * some earlier push-backs. - */ + (statePtr->inQueueHead != (ChannelBuffer *) NULL)) { + /* + * Remark: It is possible that the channel buffers contain + * data from some earlier push-backs. + */ - statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead; - prevChanPtr->inQueueHead = statePtr->inQueueHead; + statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead; + prevChanPtr->inQueueHead = statePtr->inQueueHead; - if (prevChanPtr->inQueueTail == (ChannelBuffer*) NULL) { - prevChanPtr->inQueueTail = statePtr->inQueueTail; - } + if (prevChanPtr->inQueueTail == (ChannelBuffer *) NULL) { + prevChanPtr->inQueueTail = statePtr->inQueueTail; + } - statePtr->inQueueHead = (ChannelBuffer*) NULL; - statePtr->inQueueTail = (ChannelBuffer*) NULL; + statePtr->inQueueHead = (ChannelBuffer *) NULL; + statePtr->inQueueTail = (ChannelBuffer *) NULL; } chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); @@ -1394,8 +1393,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) chanPtr->typePtr = typePtr; chanPtr->downChanPtr = prevChanPtr; chanPtr->upChanPtr = (Channel *) NULL; - chanPtr->inQueueHead = (ChannelBuffer*) NULL; - chanPtr->inQueueTail = (ChannelBuffer*) NULL; + chanPtr->inQueueHead = (ChannelBuffer *) NULL; + chanPtr->inQueueTail = (ChannelBuffer *) NULL; /* * Place new block at the head of a possibly existing list of previously @@ -1427,11 +1426,11 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) */ int -Tcl_UnstackChannel (interp, chan) +Tcl_UnstackChannel(interp, chan) 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; @@ -1442,12 +1441,13 @@ Tcl_UnstackChannel (interp, chan) 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. */ + Channel *downChanPtr = chanPtr->downChanPtr; /* @@ -1459,13 +1459,13 @@ Tcl_UnstackChannel (interp, chan) */ if (statePtr->flags & TCL_WRITABLE) { - CopyState* csPtr; + CopyState *csPtr; - csPtr = statePtr->csPtr; - statePtr->csPtr = (CopyState*) NULL; + csPtr = statePtr->csPtr; + statePtr->csPtr = (CopyState *) NULL; if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) { - statePtr->csPtr = csPtr; + statePtr->csPtr = csPtr; Tcl_AppendResult(interp, "could not flush channel \"", Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"", (char *) NULL); @@ -1485,33 +1485,33 @@ Tcl_UnstackChannel (interp, chan) * input queue and then call 'DiscardInputQueued' on that. */ - if (((statePtr->flags & TCL_READABLE) != 0) && - ((statePtr->inQueueHead != (ChannelBuffer*) NULL) || - (chanPtr->inQueueHead != (ChannelBuffer*) NULL))) { + if (((statePtr->flags & TCL_READABLE) != 0) && + ((statePtr->inQueueHead != (ChannelBuffer *) NULL) || + (chanPtr->inQueueHead != (ChannelBuffer *) NULL))) { - if ((statePtr->inQueueHead != (ChannelBuffer*) NULL) && - (chanPtr->inQueueHead != (ChannelBuffer*) NULL)) { - statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead; + if ((statePtr->inQueueHead != (ChannelBuffer *) NULL) && + (chanPtr->inQueueHead != (ChannelBuffer *) NULL)) { + statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead; statePtr->inQueueTail = chanPtr->inQueueTail; - statePtr->inQueueHead = statePtr->inQueueTail; + statePtr->inQueueHead = statePtr->inQueueTail; - } else if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) { - statePtr->inQueueHead = chanPtr->inQueueHead; + } else if (chanPtr->inQueueHead != (ChannelBuffer *) NULL) { + statePtr->inQueueHead = chanPtr->inQueueHead; statePtr->inQueueTail = chanPtr->inQueueTail; } - chanPtr->inQueueHead = (ChannelBuffer*) NULL; - chanPtr->inQueueTail = (ChannelBuffer*) NULL; + chanPtr->inQueueHead = (ChannelBuffer *) NULL; + chanPtr->inQueueTail = (ChannelBuffer *) NULL; - DiscardInputQueued (statePtr, 0); + DiscardInputQueued(statePtr, 0); } - statePtr->topChanPtr = downChanPtr; - downChanPtr->upChanPtr = (Channel *) NULL; + statePtr->topChanPtr = downChanPtr; + downChanPtr->upChanPtr = (Channel *) NULL; /* * Leave this link intact for closeproc - * chanPtr->downChanPtr = (Channel *) NULL; + * chanPtr->downChanPtr = (Channel *) NULL; */ /* @@ -1526,10 +1526,12 @@ Tcl_UnstackChannel (interp, chan) interp, 0); } - chanPtr->typePtr = NULL; + chanPtr->typePtr = NULL; + /* * AK: Tcl_NotifyChannel may hold a reference to this block of memory */ + Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC); UpdateInterest(downChanPtr); @@ -1538,15 +1540,15 @@ Tcl_UnstackChannel (interp, chan) return TCL_ERROR; } } else { - /* + /* * This channel does not cover another one. * Simply do a close, if necessary. */ - if (statePtr->refCount <= 0) { - if (Tcl_Close(interp, chan) != TCL_OK) { - return TCL_ERROR; - } + if (statePtr->refCount <= 0) { + if (Tcl_Close(interp, chan) != TCL_OK) { + return TCL_ERROR; + } } } @@ -1703,7 +1705,7 @@ Tcl_GetChannelType(chan) int Tcl_GetChannelMode(chan) Tcl_Channel chan; /* The channel for which the mode is - * being computed. */ + * being computed. */ { ChannelState *statePtr = ((Channel *) chan)->state; /* State of actual channel. */ @@ -1841,15 +1843,15 @@ 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. */ + * OS, always. */ { /* * Do we have to free the buffer to the OS? */ if (mustDiscard) { - ckfree((char *) bufPtr); - return; + ckfree((char *) bufPtr); + return; } /* @@ -1859,24 +1861,24 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) */ if ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize) { - ckfree((char *) bufPtr); - return; + ckfree((char *) bufPtr); + return; } /* * Only save buffers for the input queue if the channel is readable. */ - + if (statePtr->flags & TCL_READABLE) { - if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { - statePtr->inQueueHead = bufPtr; - statePtr->inQueueTail = bufPtr; - goto keepit; - } - if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) { - statePtr->saveInBufPtr = bufPtr; - goto keepit; - } + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { + statePtr->inQueueHead = bufPtr; + statePtr->inQueueTail = bufPtr; + goto keepit; + } + if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) { + statePtr->saveInBufPtr = bufPtr; + goto keepit; + } } /* @@ -1884,10 +1886,10 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) */ if (statePtr->flags & TCL_WRITABLE) { - if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { - statePtr->curOutPtr = bufPtr; - goto keepit; - } + if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { + statePtr->curOutPtr = bufPtr; + goto keepit; + } } /* @@ -1924,11 +1926,11 @@ DiscardOutputQueued(statePtr) ChannelState *statePtr; /* ChannelState for which to discard output. */ { ChannelBuffer *bufPtr; - + while (statePtr->outQueueHead != (ChannelBuffer *) NULL) { - bufPtr = statePtr->outQueueHead; - statePtr->outQueueHead = bufPtr->nextPtr; - RecycleBuffer(statePtr, bufPtr, 0); + bufPtr = statePtr->outQueueHead; + statePtr->outQueueHead = bufPtr->nextPtr; + RecycleBuffer(statePtr, bufPtr, 0); } statePtr->outQueueHead = (ChannelBuffer *) NULL; statePtr->outQueueTail = (ChannelBuffer *) NULL; @@ -1940,13 +1942,13 @@ DiscardOutputQueued(statePtr) * CheckForDeadChannel -- * * This function checks is a given channel is Dead. - * (A channel that has been closed but not yet deallocated.) + * (A channel that has been closed but not yet deallocated.) * * Results: * True (1) if channel is Dead, False (0) if channel is Ok * * Side effects: - * None + * None * *---------------------------------------------------------------------- */ @@ -1957,7 +1959,7 @@ CheckForDeadChannel(interp, statePtr) ChannelState *statePtr; /* The channel state to check. */ { if (statePtr->flags & CHANNEL_DEAD) { - Tcl_SetErrno(EINVAL); + Tcl_SetErrno(EINVAL); if (interp) { Tcl_AppendResult(interp, "unable to access channel: invalid channel", @@ -1994,19 +1996,19 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) Tcl_Interp *interp; /* For error reporting during close. */ Channel *chanPtr; /* The channel to flush on. */ int calledFromAsyncFlush; /* If nonzero then we are being - * called from an asynchronous - * flush callback. */ + * called from an asynchronous + * flush callback. */ { ChannelState *statePtr = chanPtr->state; /* State of the channel stack. */ ChannelBuffer *bufPtr; /* Iterates over buffered output - * queue. */ + * queue. */ int toWrite; /* Amount of output data in current - * buffer available to be written. */ + * buffer available to be written. */ int written; /* Amount of output data actually - * written in current round. */ + * written in current round. */ int errorCode = 0; /* Stores POSIX error codes from - * channel driver operations. */ + * channel driver operations. */ int wroteSome = 0; /* Set to one if any data was * written to the driver. */ @@ -2016,9 +2018,11 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) * channel deallocation runs before all channels are deregistered in * all interpreters. */ - - if (CheckForDeadChannel(interp, statePtr)) return -1; - + + if (CheckForDeadChannel(interp, statePtr)) { + return -1; + } + /* * Loop over the queued buffers and attempt to flush as * much as possible of the queued output to the channel. @@ -2026,102 +2030,103 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) while (1) { - /* - * If the queue is empty and there is a ready current buffer, OR if - * the current buffer is full, then move the current buffer to the - * queue. - */ - - 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 { - statePtr->outQueueTail->nextPtr = statePtr->curOutPtr; - } - statePtr->outQueueTail = statePtr->curOutPtr; - statePtr->curOutPtr = (ChannelBuffer *) NULL; - } - bufPtr = statePtr->outQueueHead; - - /* - * If we are not being called from an async flush and an async - * flush is active, we just return without producing any output. - */ - - if ((!calledFromAsyncFlush) && - (statePtr->flags & BG_FLUSH_SCHEDULED)) { - return 0; - } - - /* - * If the output queue is still empty, break out of the while loop. - */ - - if (bufPtr == (ChannelBuffer *) NULL) { - break; /* Out of the "while (1)". */ - } - - /* - * Produce the output on the channel. - */ - - toWrite = bufPtr->nextAdded - bufPtr->nextRemoved; - written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData, - bufPtr->buf + bufPtr->nextRemoved, toWrite, + /* + * If the queue is empty and there is a ready current buffer, OR if + * the current buffer is full, then move the current buffer to the + * queue. + */ + + 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 { + statePtr->outQueueTail->nextPtr = statePtr->curOutPtr; + } + statePtr->outQueueTail = statePtr->curOutPtr; + statePtr->curOutPtr = (ChannelBuffer *) NULL; + } + bufPtr = statePtr->outQueueHead; + + /* + * If we are not being called from an async flush and an async + * flush is active, we just return without producing any output. + */ + + if ((!calledFromAsyncFlush) && + (statePtr->flags & BG_FLUSH_SCHEDULED)) { + return 0; + } + + /* + * If the output queue is still empty, break out of the while loop. + */ + + if (bufPtr == (ChannelBuffer *) NULL) { + break; /* Out of the "while (1)". */ + } + + /* + * Produce the output on the channel. + */ + + toWrite = bufPtr->nextAdded - bufPtr->nextRemoved; + written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData, + 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 - * write any more output at this time. - */ - - if (written < 0) { - - /* - * If the last attempt to write was interrupted, simply retry. - */ - - if (errorCode == EINTR) { - errorCode = 0; - continue; - } - - /* - * If the channel is non-blocking and we would have blocked, - * start a background flushing handler and break out of the loop. - */ - - if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) { + * If the write failed completely attempt to start the asynchronous + * flush mechanism and break out of this loop - do not attempt to + * write any more output at this time. + */ + + if (written < 0) { + + /* + * If the last attempt to write was interrupted, simply retry. + */ + + if (errorCode == EINTR) { + errorCode = 0; + continue; + } + + /* + * If the channel is non-blocking and we would have blocked, + * start a background flushing handler and break out of the loop. + */ + + if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) { /* * This used to check for CHANNEL_NONBLOCKING, and panic - * if the channel was blocking. However, it appears + * if the channel was blocking. However, it appears * that setting stdin to -blocking 0 has some effect on * the stdout when it's a tty channel (dup'ed underneath) */ + if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { statePtr->flags |= BG_FLUSH_SCHEDULED; UpdateInterest(chanPtr); } errorCode = 0; break; - } - - /* - * Decide whether to report the error upwards or defer it. - */ - - if (calledFromAsyncFlush) { - if (statePtr->unreportedError == 0) { - statePtr->unreportedError = errorCode; - } - } else { - Tcl_SetErrno(errorCode); + } + + /* + * Decide whether to report the error upwards or defer it. + */ + + if (calledFromAsyncFlush) { + if (statePtr->unreportedError == 0) { + statePtr->unreportedError = errorCode; + } + } else { + Tcl_SetErrno(errorCode); if (interp != NULL) { /* @@ -2133,32 +2138,32 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) Tcl_SetResult(interp, (char *) Tcl_PosixError(interp), TCL_VOLATILE); } - } + } - /* - * When we get an error we throw away all the output - * currently queued. - */ + /* + * When we get an error we throw away all the output + * currently queued. + */ - DiscardOutputQueued(statePtr); - continue; - } else { + DiscardOutputQueued(statePtr); + continue; + } else { wroteSome = 1; } - bufPtr->nextRemoved += written; + bufPtr->nextRemoved += written; - /* - * If this buffer is now empty, recycle it. - */ + /* + * If this buffer is now empty, recycle it. + */ - if (bufPtr->nextRemoved == bufPtr->nextAdded) { - statePtr->outQueueHead = bufPtr->nextPtr; - if (statePtr->outQueueHead == (ChannelBuffer *) NULL) { - statePtr->outQueueTail = (ChannelBuffer *) NULL; - } - RecycleBuffer(statePtr, bufPtr, 0); - } + if (bufPtr->nextRemoved == bufPtr->nextAdded) { + statePtr->outQueueHead = bufPtr->nextPtr; + if (statePtr->outQueueHead == (ChannelBuffer *) NULL) { + statePtr->outQueueTail = (ChannelBuffer *) NULL; + } + RecycleBuffer(statePtr, bufPtr, 0); + } } /* Closes "while (1)". */ /* @@ -2185,10 +2190,10 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) */ if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) && - (statePtr->outQueueHead == (ChannelBuffer *) NULL) && - ((statePtr->curOutPtr == (ChannelBuffer *) NULL) || - (statePtr->curOutPtr->nextAdded == - statePtr->curOutPtr->nextRemoved))) { + (statePtr->outQueueHead == (ChannelBuffer *) NULL) && + ((statePtr->curOutPtr == (ChannelBuffer *) NULL) || + (statePtr->curOutPtr->nextAdded == + statePtr->curOutPtr->nextRemoved))) { return CloseChannel(interp, chanPtr, errorCode); } return errorCode; @@ -2225,12 +2230,12 @@ CloseChannel(interp, chanPtr, errorCode) int errorCode; /* Status of operation so far. */ { int result = 0; /* Of calling driver close - * operation. */ + * operation. */ ChannelState *statePtr; /* state of the channel stack. */ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); if (chanPtr == NULL) { - return result; + return result; } statePtr = chanPtr->state; @@ -2245,17 +2250,17 @@ CloseChannel(interp, chanPtr, errorCode) */ if (statePtr->curOutPtr != (ChannelBuffer *) NULL) { - ckfree((char *) statePtr->curOutPtr); - statePtr->curOutPtr = (ChannelBuffer *) NULL; + ckfree((char *) statePtr->curOutPtr); + statePtr->curOutPtr = (ChannelBuffer *) NULL; } - + /* * The caller guarantees that there are no more buffers * queued for output. */ if (statePtr->outQueueHead != (ChannelBuffer *) NULL) { - Tcl_Panic("TclFlush, closed channel: queued output left"); + Tcl_Panic("TclFlush, closed channel: queued output left"); } /* @@ -2264,16 +2269,16 @@ CloseChannel(interp, chanPtr, errorCode) */ if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) { - int dummy; - char c; + int dummy; + char c = (char) statePtr->outEofChar; - c = (char) statePtr->outEofChar; - (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy); + (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy); } /* * Remove this channel from of the list of all channels. */ + Tcl_CutChannel((Tcl_Channel) chanPtr); /* @@ -2283,8 +2288,8 @@ CloseChannel(interp, chanPtr, errorCode) if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp); } else { - result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp, - 0); + result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, + interp, 0); } /* @@ -2312,13 +2317,13 @@ CloseChannel(interp, chanPtr, errorCode) */ if (statePtr->unreportedError != 0) { - errorCode = statePtr->unreportedError; + errorCode = statePtr->unreportedError; } if (errorCode == 0) { - errorCode = result; - if (errorCode != 0) { - Tcl_SetErrno(errorCode); - } + errorCode = result; + if (errorCode != 0) { + Tcl_SetErrno(errorCode); + } } /* @@ -2352,6 +2357,7 @@ CloseChannel(interp, chanPtr, errorCode) * ChannelState structure associated with it. We use * Tcl_EventuallyFree to allow for any last */ + chanPtr->typePtr = NULL; Tcl_EventuallyFree((ClientData) statePtr, TCL_DYNAMIC); @@ -2389,13 +2395,13 @@ CloseChannel(interp, chanPtr, errorCode) void Tcl_CutChannel(chan) Tcl_Channel chan; /* The channel being removed. Must - * not be referenced in any - * interpreter. */ + * not be referenced in any + * interpreter. */ { - ThreadSpecificData* tsdPtr = TCL_TSD_INIT(&dataKey); + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ChannelState *prevCSPtr; /* Preceding channel state in list of - * all states - used to splice a - * channel out of the list on close. */ + * all states - used to splice a + * channel out of the list on close. */ ChannelState *statePtr = ((Channel *) chan)->state; /* state of the channel stack. */ @@ -2405,17 +2411,17 @@ Tcl_CutChannel(chan) */ if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) { - tsdPtr->firstCSPtr = statePtr->nextCSPtr; + tsdPtr->firstCSPtr = statePtr->nextCSPtr; } else { - for (prevCSPtr = tsdPtr->firstCSPtr; - prevCSPtr && (prevCSPtr->nextCSPtr != statePtr); - prevCSPtr = prevCSPtr->nextCSPtr) { - /* Empty loop body. */ - } - if (prevCSPtr == (ChannelState *) NULL) { - Tcl_Panic("FlushChannel: damaged channel list"); - } - prevCSPtr->nextCSPtr = statePtr->nextCSPtr; + for (prevCSPtr = tsdPtr->firstCSPtr; + prevCSPtr && (prevCSPtr->nextCSPtr != statePtr); + prevCSPtr = prevCSPtr->nextCSPtr) { + /* Empty loop body. */ + } + if (prevCSPtr == (ChannelState *) NULL) { + Tcl_Panic("FlushChannel: damaged channel list"); + } + prevCSPtr->nextCSPtr = statePtr->nextCSPtr; } statePtr->nextCSPtr = (ChannelState *) NULL; @@ -2453,26 +2459,26 @@ Tcl_CutChannel(chan) void Tcl_SpliceChannel(chan) Tcl_Channel chan; /* The channel being added. Must - * not be referenced in any - * interpreter. */ + * not be referenced in any + * interpreter. */ { - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - ChannelState *statePtr = ((Channel *) chan)->state; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *statePtr = ((Channel *) chan)->state; if (statePtr->nextCSPtr != (ChannelState *) NULL) { - Tcl_Panic("Tcl_SpliceChannel: trying to add channel used in different list"); + Tcl_Panic("Tcl_SpliceChannel: trying to add channel used in different list"); } - statePtr->nextCSPtr = tsdPtr->firstCSPtr; - tsdPtr->firstCSPtr = statePtr; + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; /* * TIP #10. Mark the current thread as the new one managing this - * channel. Note: 'Tcl_GetCurrentThread' returns sensible - * values even for a non-threaded core. + * channel. Note: 'Tcl_GetCurrentThread' returns sensible + * values even for a non-threaded core. */ - statePtr->managingThread = Tcl_GetCurrentThread (); + statePtr->managingThread = Tcl_GetCurrentThread(); TclpSpliceFileChannel(chan); TclpSpliceSockChannel(chan); @@ -2505,17 +2511,17 @@ int Tcl_Close(interp, chan) Tcl_Interp *interp; /* Interpreter for errors. */ Tcl_Channel chan; /* The channel being closed. Must - * not be referenced in any - * interpreter. */ + * not be referenced in any + * interpreter. */ { CloseCallback *cbPtr; /* Iterate over close callbacks - * for this channel. */ + * 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; + return TCL_OK; } /* @@ -2532,19 +2538,18 @@ Tcl_Close(interp, chan) * This operation should occur at the top of a channel stack. */ - chanPtr = (Channel *) chan; - statePtr = chanPtr->state; - chanPtr = statePtr->topChanPtr; + chanPtr = (Channel *) chan; + statePtr = chanPtr->state; + chanPtr = statePtr->topChanPtr; if (statePtr->refCount > 0) { - Tcl_Panic("called Tcl_Close on channel with refCount > 0"); + Tcl_Panic("called Tcl_Close on channel with refCount > 0"); } if (statePtr->flags & CHANNEL_INCLOSE) { - Tcl_AppendResult(interp, - "Illegal recursive call to close through close-handler of channel", - (char *) NULL); - return TCL_ERROR; + Tcl_AppendResult(interp, "Illegal recursive call to close ", + "through close-handler of channel", (char *) NULL); + return TCL_ERROR; } statePtr->flags |= CHANNEL_INCLOSE; @@ -2554,8 +2559,8 @@ Tcl_Close(interp, chan) */ if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL) && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) { - statePtr->outputEncodingFlags |= TCL_ENCODING_END; - WriteChars(chanPtr, "", 0); + statePtr->outputEncodingFlags |= TCL_ENCODING_END; + WriteChars(chanPtr, "", 0); } Tcl_ClearChannelHandlers(chan); @@ -2565,10 +2570,10 @@ Tcl_Close(interp, chan) */ while (statePtr->closeCbPtr != (CloseCallback *) NULL) { - cbPtr = statePtr->closeCbPtr; - statePtr->closeCbPtr = cbPtr->nextPtr; - (cbPtr->proc) (cbPtr->clientData); - ckfree((char *) cbPtr); + cbPtr = statePtr->closeCbPtr; + statePtr->closeCbPtr = cbPtr->nextPtr; + (cbPtr->proc) (cbPtr->clientData); + ckfree((char *) cbPtr); } statePtr->flags &= ~CHANNEL_INCLOSE; @@ -2576,10 +2581,10 @@ Tcl_Close(interp, chan) /* * Ensure that the last output buffer will be flushed. */ - + if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) && (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) { - statePtr->flags |= BUFFER_READY; + statePtr->flags |= BUFFER_READY; } /* @@ -2602,7 +2607,7 @@ Tcl_Close(interp, chan) statePtr->flags |= CHANNEL_CLOSED; if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) { - return TCL_ERROR; + return TCL_ERROR; } return TCL_OK; } @@ -2626,7 +2631,7 @@ Tcl_Close(interp, chan) */ void -Tcl_ClearChannelHandlers (channel) +Tcl_ClearChannelHandlers(channel) Tcl_Channel channel; { ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */ @@ -2640,9 +2645,9 @@ Tcl_ClearChannelHandlers (channel) * This operation should occur at the top of a channel stack. */ - chanPtr = (Channel *) channel; - statePtr = chanPtr->state; - chanPtr = statePtr->topChanPtr; + chanPtr = (Channel *) channel; + statePtr = chanPtr->state; + chanPtr = statePtr->topChanPtr; /* * Remove any references to channel handlers for this channel that @@ -2650,12 +2655,12 @@ Tcl_ClearChannelHandlers (channel) */ for (nhPtr = tsdPtr->nestedHandlerPtr; - nhPtr != (NextChannelHandler *) NULL; - nhPtr = nhPtr->nestedHandlerPtr) { - if (nhPtr->nextHandlerPtr && + nhPtr != (NextChannelHandler *) NULL; + nhPtr = nhPtr->nestedHandlerPtr) { + if (nhPtr->nextHandlerPtr && (nhPtr->nextHandlerPtr->chanPtr == chanPtr)) { nhPtr->nextHandlerPtr = NULL; - } + } } /* @@ -2664,10 +2669,10 @@ Tcl_ClearChannelHandlers (channel) */ for (chPtr = statePtr->chPtr; - chPtr != (ChannelHandler *) NULL; - chPtr = chNext) { - chNext = chPtr->nextPtr; - ckfree((char *) chPtr); + chPtr != (ChannelHandler *) NULL; + chPtr = chNext) { + chNext = chPtr->nextPtr; + ckfree((char *) chPtr); } statePtr->chPtr = (ChannelHandler *) NULL; @@ -2683,19 +2688,19 @@ Tcl_ClearChannelHandlers (channel) * finally deleted in FlushChannel. This can happen if the channel * has a background flush active. */ - + statePtr->interestMask = 0; - + /* * Remove any EventScript records for this channel. */ for (ePtr = statePtr->scriptRecordPtr; - ePtr != (EventScriptRecord *) NULL; - ePtr = eNextPtr) { - eNextPtr = ePtr->nextPtr; - Tcl_DecrRefCount(ePtr->scriptPtr); - ckfree((char *) ePtr); + ePtr != (EventScriptRecord *) NULL; + ePtr = eNextPtr) { + eNextPtr = ePtr->nextPtr; + TclDecrRefCount(ePtr->scriptPtr); + ckfree((char *) ePtr); } statePtr->scriptRecordPtr = (EventScriptRecord *) NULL; } @@ -2734,18 +2739,19 @@ Tcl_Write(chan, src, srcLen) /* * Always use the topmost channel of the stack */ + Channel *chanPtr; ChannelState *statePtr; /* state info for channel */ statePtr = ((Channel *) chan)->state; - chanPtr = statePtr->topChanPtr; + chanPtr = statePtr->topChanPtr; if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { return -1; } if (srcLen < 0) { - srcLen = strlen(src); + srcLen = strlen(src); } return DoWrite(chanPtr, src, srcLen); } @@ -2790,7 +2796,7 @@ Tcl_WriteRaw(chan, src, srcLen) } if (srcLen < 0) { - srcLen = strlen(src); + srcLen = strlen(src); } /* @@ -2846,7 +2852,7 @@ Tcl_WriteChars(chan, src, len) return -1; } - return DoWriteChars ((Channel*) chan, src, len); + return DoWriteChars((Channel *) chan, src, len); } /* @@ -2874,7 +2880,7 @@ Tcl_WriteChars(chan, src, len) static int DoWriteChars(chanPtr, src, len) - Channel* chanPtr; /* The channel to buffer output for. */ + Channel *chanPtr; /* The channel to buffer output for. */ CONST char *src; /* UTF-8 characters to queue in output buffer. */ int len; /* Length of string in bytes, or < 0 for * strlen(). */ @@ -2882,13 +2888,14 @@ DoWriteChars(chanPtr, src, len) /* * Always use the topmost channel of the stack */ + ChannelState *statePtr; /* state info for channel */ statePtr = chanPtr->state; - chanPtr = statePtr->topChanPtr; + chanPtr = statePtr->topChanPtr; if (len < 0) { - len = strlen(src); + len = strlen(src); } if (statePtr->encoding == NULL) { /* @@ -2902,7 +2909,7 @@ DoWriteChars(chanPtr, src, len) objPtr = Tcl_NewStringObj(src, len); src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len); result = WriteBytes(chanPtr, src, len); - Tcl_DecrRefCount(objPtr); + TclDecrRefCount(objPtr); return result; } return WriteChars(chanPtr, src, len); @@ -2947,7 +2954,7 @@ Tcl_WriteObj(chan, objPtr) int srcLen; statePtr = ((Channel *) chan)->state; - chanPtr = statePtr->topChanPtr; + chanPtr = statePtr->topChanPtr; if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { return -1; @@ -2992,7 +2999,7 @@ WriteBytes(chanPtr, src, srcLen) ChannelBuffer *bufPtr; char *dst; int dstMax, sawLF, savedLF, total, dstLen, toWrite; - + total = 0; sawLF = 0; savedLF = 0; @@ -3006,7 +3013,7 @@ WriteBytes(chanPtr, src, srcLen) bufPtr = statePtr->curOutPtr; if (bufPtr == NULL) { bufPtr = AllocChannelBuffer(statePtr->bufSize); - statePtr->curOutPtr = bufPtr; + statePtr->curOutPtr = bufPtr; } dst = bufPtr->buf + bufPtr->nextAdded; dstMax = bufPtr->bufLength - bufPtr->nextAdded; @@ -3086,7 +3093,7 @@ WriteChars(chanPtr, src, srcLen) int consumedSomething; Tcl_Encoding encoding; char safe[BUFFER_PADDING]; - + total = 0; sawLF = 0; savedLF = 0; @@ -3106,7 +3113,7 @@ WriteChars(chanPtr, src, srcLen) consumedSomething = 1; while (consumedSomething && (srcLen + savedLF + endEncoding > 0)) { - consumedSomething = 0; + consumedSomething = 0; stage = statePtr->outputStage; stageMax = statePtr->bufSize; stageLen = stageMax; @@ -3123,7 +3130,7 @@ WriteChars(chanPtr, src, srcLen) * channel is line-based, we will need to flush the output * buffer (after translating the staging buffer). */ - + *stage++ = '\n'; stageLen--; sawLF++; @@ -3163,7 +3170,7 @@ WriteChars(chanPtr, src, srcLen) * buffer that we need to stick at the beginning of this * buffer. */ - + memcpy((VOID *) dst, (VOID *) safe, (size_t) saved); bufPtr->nextAdded += saved; dst += saved; @@ -3192,9 +3199,11 @@ WriteChars(chanPtr, src, srcLen) */ statePtr->outputEncodingFlags &= ~TCL_ENCODING_START; + /* * The following code must be executed only when result is not 0. */ + if ((result != 0) && ((stageRead + dstWrote) == 0)) { /* * We have an incomplete UTF-8 character at the end of the @@ -3251,8 +3260,8 @@ WriteChars(chanPtr, src, srcLen) */ if (!consumedSomething && (total == 0)) { - Tcl_SetErrno (EINVAL); - return -1; + Tcl_SetErrno(EINVAL); + return -1; } return total; } @@ -3314,7 +3323,7 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) { char *dstEnd; int srcLen, newlineFound; - + newlineFound = 0; srcLen = *srcLenPtr; @@ -3353,12 +3362,12 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) char *dstStart, *dstMax; CONST char *srcStart; - + dstStart = dst; dstMax = dst + *dstLenPtr; srcStart = src; - + if (srcLen < *dstLenPtr) { dstEnd = dst + srcLen; } else { @@ -3468,13 +3477,13 @@ Tcl_Gets(chan, lineRead) int charsStored, length; char *string; - objPtr = Tcl_NewObj(); + TclNewObj(objPtr); charsStored = Tcl_GetsObj(chan, objPtr); if (charsStored > 0) { string = Tcl_GetStringFromObj(objPtr, &length); Tcl_DStringAppend(lineRead, string, length); } - Tcl_DecrRefCount(objPtr); + TclDecrRefCount(objPtr); return charsStored; } @@ -3584,7 +3593,7 @@ Tcl_GetsObj(chan, objPtr) } dstEnd = dst + gs.bytesWrote; } - + /* * Remember if EOF char is seen, then look for EOL anyhow, because * the EOL might be before the EOF char. @@ -3637,7 +3646,7 @@ Tcl_GetsObj(chan, objPtr) if (eol >= dstEnd) { int offset; - + offset = eol - objPtr->bytes; dst = dstEnd; if (FilterInputBytes(chanPtr, &gs) != 0) { @@ -3696,7 +3705,7 @@ Tcl_GetsObj(chan, objPtr) */ int offset; - + offset = eol - objPtr->bytes; dst = dstEnd; PeekAhead(chanPtr, &dstEnd, &gs); @@ -3755,7 +3764,7 @@ Tcl_GetsObj(chan, objPtr) * correspond to the character(s) making up EOL (if any), so we can * remove the correct number of bytes from the channel buffer. */ - + goteol: bufPtr = gs.bufPtr; statePtr->inputEncodingState = gs.state; @@ -3842,7 +3851,7 @@ Tcl_GetsObj(chan, objPtr) * *--------------------------------------------------------------------------- */ - + static int FilterInputBytes(chanPtr, gsPtr) Channel *chanPtr; /* Channel to read. */ @@ -3885,14 +3894,14 @@ FilterInputBytes(chanPtr, gsPtr) */ read: - if (statePtr->flags & CHANNEL_BLOCKED) { - if (statePtr->flags & CHANNEL_NONBLOCKING) { + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { gsPtr->charsWrote = 0; gsPtr->rawRead = 0; return -1; } - statePtr->flags &= ~CHANNEL_BLOCKED; - } + statePtr->flags &= ~CHANNEL_BLOCKED; + } if (GetInput(chanPtr) != 0) { gsPtr->charsWrote = 0; gsPtr->rawRead = 0; @@ -3942,6 +3951,7 @@ FilterInputBytes(chanPtr, gsPtr) * Make sure that if we go through 'gets', that we reset the * TCL_ENCODING_START flag still. [Bug #523988] */ + statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; if (result == TCL_CONVERT_MULTIBYTE) { @@ -3953,7 +3963,7 @@ FilterInputBytes(chanPtr, gsPtr) ChannelBuffer *nextPtr; int extra; - + nextPtr = bufPtr->nextPtr; if (bufPtr->nextAdded < bufPtr->bufLength) { if (gsPtr->rawRead > 0) { @@ -4047,7 +4057,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr) /* * Don't peek ahead if last read was short read. */ - + goto cleanup; } if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) { @@ -4095,7 +4105,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr) * *--------------------------------------------------------------------------- */ - + static void CommonGetsCleanup(chanPtr, encoding) Channel *chanPtr; @@ -4103,7 +4113,7 @@ CommonGetsCleanup(chanPtr, encoding) { ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr, *nextPtr; - + bufPtr = statePtr->inQueueHead; for ( ; bufPtr != NULL; bufPtr = nextPtr) { nextPtr = bufPtr->nextPtr; @@ -4124,7 +4134,7 @@ CommonGetsCleanup(chanPtr, encoding) * encoding which could change the interpretation of whether those * bytes really made up multi-byte characters after all. */ - + nextPtr = bufPtr->nextPtr; for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) { int extra; @@ -4245,18 +4255,18 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) */ for (copied = 0; copied < bytesToRead; copied += copiedNow) { - copiedNow = CopyBuffer(chanPtr, bufPtr + copied, - bytesToRead - copied); - if (copiedNow == 0) { - if (statePtr->flags & CHANNEL_EOF) { + 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) { + } + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { goto done; - } - statePtr->flags &= (~(CHANNEL_BLOCKED)); - } + } + statePtr->flags &= (~(CHANNEL_BLOCKED)); + } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING /* [SF Tcl Bug 943274]. Better emulation of non-blocking @@ -4267,59 +4277,65 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) */ if ((statePtr->flags & CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { - - /* We bypass the driver, it would block, as no data is available */ - nread = -1; - result = EWOULDBLOCK; + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { + /* + * We bypass the driver, it would block, as no data is + * available + */ + nread = -1; + result = EWOULDBLOCK; } else { #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - /* - * 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); + /* + * 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); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ 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)) { + + if (nread < (bytesToRead - copied)) { statePtr->flags |= CHANNEL_BLOCKED; } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - if (nread <= (bytesToRead - copied)) { - /* [SF Tcl Bug 943274] We have read the available - * data, clear flag */ + if (nread <= (bytesToRead - copied)) { + /* + * [SF Tcl Bug 943274] We have read the available + * data, clear flag. + */ + statePtr->flags &= ~CHANNEL_HAS_MORE_DATA; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ } else if (nread == 0) { - statePtr->flags |= CHANNEL_EOF; + statePtr->flags |= CHANNEL_EOF; statePtr->inputEncodingFlags |= TCL_ENCODING_END; } else if (nread < 0) { - if ((result == EWOULDBLOCK) || (result == EAGAIN)) { + if ((result == EWOULDBLOCK) || (result == EAGAIN)) { if (copied > 0) { - /* - * Information that was copied earlier has precedence - * over EAGAIN/WOULDBLOCK handling. - */ - return copied; + /* + * Information that was copied earlier has precedence + * over EAGAIN/WOULDBLOCK handling. + */ + + return copied; } statePtr->flags |= CHANNEL_BLOCKED; @@ -4331,7 +4347,7 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) } return copied + nread; - } + } } done: @@ -4359,7 +4375,7 @@ done: * *--------------------------------------------------------------------------- */ - + int Tcl_ReadChars(chan, objPtr, toRead, appendFlag) Tcl_Channel chan; /* The channel to read. */ @@ -4371,11 +4387,10 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag) * will be appended to the object. Otherwise, * the data will replace the existing contents * of the object. */ - { - Channel* chanPtr = (Channel *) chan; - ChannelState* statePtr = chanPtr->state; /* state info for channel */ - + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; /* state info for channel */ + /* * This operation should occur at the top of a channel stack. */ @@ -4383,15 +4398,16 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag) chanPtr = statePtr->topChanPtr; if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { - /* + /* * Update the notifier state so we don't block while there is still * data in the buffers. */ - UpdateInterest(chanPtr); + + UpdateInterest(chanPtr); return -1; } - return DoReadChars (chanPtr, objPtr, toRead, appendFlag); + return DoReadChars(chanPtr, objPtr, toRead, appendFlag); } /* *--------------------------------------------------------------------------- @@ -4414,10 +4430,10 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag) * *--------------------------------------------------------------------------- */ - + static int DoReadChars(chanPtr, objPtr, toRead, appendFlag) - Channel* chanPtr; /* The channel to read. */ + Channel *chanPtr; /* The channel to read. */ Tcl_Obj *objPtr; /* Input data is stored in this object. */ int toRead; /* Maximum number of characters to store, * or -1 to read all available data (up to EOF @@ -4426,7 +4442,6 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) * will be appended to the object. Otherwise, * the data will replace the existing contents * of the object. */ - { ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; @@ -4438,9 +4453,9 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) * This operation should occur at the top of a channel stack. */ - chanPtr = statePtr->topChanPtr; + chanPtr = statePtr->topChanPtr; encoding = statePtr->encoding; - factor = UTF_EXPANSION_FACTOR; + factor = UTF_EXPANSION_FACTOR; if (appendFlag == 0) { if (encoding == NULL) { @@ -4452,6 +4467,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) * we must ensure that this is actually a string * object (otherwise it might have been pure Unicode). */ + Tcl_GetString(objPtr); } offset = 0; @@ -4762,7 +4778,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) } statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; *offsetPtr += 1; - return 1; + return 1; } Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen, @@ -4776,11 +4792,11 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) */ ChannelBuffer *nextPtr; - + nextPtr = bufPtr->nextPtr; if (nextPtr == NULL) { if (srcLen > 0) { - /* + /* * There isn't enough data in the buffers to complete the next * character, so we need to wait for more data before the next * file event can be delivered. @@ -4794,7 +4810,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) * was complete. */ - statePtr->flags |= CHANNEL_NEED_MORE_DATA; + statePtr->flags |= CHANNEL_NEED_MORE_DATA; } return -1; } @@ -4814,7 +4830,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) * output buffer just big enough to hold the data so we can * get the correct value for srcRead. */ - + if (dstWrote == 0) { return -1; } @@ -4933,7 +4949,7 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) } case TCL_TRANSLATE_CR: { char *dst, *dstEnd; - + if (dstStart != srcStart) { memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); } @@ -4949,7 +4965,7 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) case TCL_TRANSLATE_CRLF: { char *dst; CONST char *src, *srcEnd, *srcMax; - + dst = dstStart; src = srcStart; srcEnd = srcStart + dstLen; @@ -5054,7 +5070,7 @@ Tcl_Ungets(chan, str, len, atEnd) CONST char *str; /* The input itself. */ int len; /* The length of the input. */ int atEnd; /* If non-zero, add at end of queue; otherwise - * add at head of queue. */ + * add at head of queue. */ { Channel *chanPtr; /* The real IO channel. */ ChannelState *statePtr; /* State of actual channel. */ @@ -5073,7 +5089,7 @@ Tcl_Ungets(chan, str, len, atEnd) /* * CheckChannelErrors clears too many flag bits in this one case. */ - + flags = statePtr->flags; if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { len = -1; @@ -5096,20 +5112,20 @@ Tcl_Ungets(chan, str, len, atEnd) bufPtr = AllocChannelBuffer(len); for (i = 0; i < len; i++) { - bufPtr->buf[bufPtr->nextAdded++] = str[i]; + bufPtr->buf[bufPtr->nextAdded++] = str[i]; } if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { - bufPtr->nextPtr = (ChannelBuffer *) NULL; - statePtr->inQueueHead = bufPtr; - statePtr->inQueueTail = bufPtr; + bufPtr->nextPtr = (ChannelBuffer *) NULL; + statePtr->inQueueHead = bufPtr; + statePtr->inQueueTail = bufPtr; } else if (atEnd) { - bufPtr->nextPtr = (ChannelBuffer *) NULL; - statePtr->inQueueTail->nextPtr = bufPtr; - statePtr->inQueueTail = bufPtr; + bufPtr->nextPtr = (ChannelBuffer *) NULL; + statePtr->inQueueTail->nextPtr = bufPtr; + statePtr->inQueueTail = bufPtr; } else { - bufPtr->nextPtr = statePtr->inQueueHead; - statePtr->inQueueHead = bufPtr; + bufPtr->nextPtr = statePtr->inQueueHead; + statePtr->inQueueHead = bufPtr; } done: @@ -5143,7 +5159,7 @@ Tcl_Flush(chan) Tcl_Channel chan; /* The Channel to flush. */ { int result; /* Of calling FlushChannel. */ - Channel *chanPtr = (Channel *) chan; /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ ChannelState *statePtr = chanPtr->state; /* State of actual channel. */ /* @@ -5162,13 +5178,13 @@ Tcl_Flush(chan) if ((statePtr->curOutPtr != NULL) && (statePtr->curOutPtr->nextAdded > - statePtr->curOutPtr->nextRemoved)) { - statePtr->flags |= BUFFER_READY; + statePtr->curOutPtr->nextRemoved)) { + statePtr->flags |= BUFFER_READY; } - + result = FlushChannel(NULL, chanPtr, 0); if (result != 0) { - return TCL_ERROR; + return TCL_ERROR; } return TCL_OK; @@ -5195,9 +5211,9 @@ Tcl_Flush(chan) static void DiscardInputQueued(statePtr, discardSavedBuffers) ChannelState *statePtr; /* Channel on which to discard - * the queued input. */ + * the queued input. */ int discardSavedBuffers; /* If non-zero, discard all buffers including - * last one. */ + * last one. */ { ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */ @@ -5205,20 +5221,20 @@ DiscardInputQueued(statePtr, discardSavedBuffers) statePtr->inQueueHead = (ChannelBuffer *) NULL; statePtr->inQueueTail = (ChannelBuffer *) NULL; for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) { - nxtPtr = bufPtr->nextPtr; - RecycleBuffer(statePtr, 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 (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) { - ckfree((char *) statePtr->saveInBufPtr); - statePtr->saveInBufPtr = (ChannelBuffer *) NULL; - } + if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) { + ckfree((char *) statePtr->saveInBufPtr); + statePtr->saveInBufPtr = (ChannelBuffer *) NULL; + } } } @@ -5255,7 +5271,7 @@ GetInput(chanPtr) * channel cleanup has run but the channel is still registered in some * interpreter. */ - + if (CheckForDeadChannel(NULL, statePtr)) { return EINVAL; } @@ -5270,16 +5286,16 @@ GetInput(chanPtr) * empty buffer. In the latter case we can recycle it now. */ - if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) { - if (statePtr->inQueueHead != (ChannelBuffer*) NULL) { + if (chanPtr->inQueueHead != (ChannelBuffer *) NULL) { + if (statePtr->inQueueHead != (ChannelBuffer *) NULL) { RecycleBuffer(statePtr, statePtr->inQueueHead, 0); - statePtr->inQueueHead = (ChannelBuffer*) NULL; + statePtr->inQueueHead = (ChannelBuffer *) NULL; } statePtr->inQueueHead = chanPtr->inQueueHead; statePtr->inQueueTail = chanPtr->inQueueTail; - chanPtr->inQueueHead = (ChannelBuffer*) NULL; - chanPtr->inQueueTail = (ChannelBuffer*) NULL; + chanPtr->inQueueHead = (ChannelBuffer *) NULL; + chanPtr->inQueueTail = (ChannelBuffer *) NULL; return 0; } @@ -5296,7 +5312,7 @@ GetInput(chanPtr) bufPtr = statePtr->inQueueTail; if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) { - toRead = bufPtr->bufLength - bufPtr->nextAdded; + toRead = bufPtr->bufLength - bufPtr->nextAdded; } else { bufPtr = statePtr->saveInBufPtr; statePtr->saveInBufPtr = NULL; @@ -5308,15 +5324,16 @@ GetInput(chanPtr) * buffersize made by the user. */ - if ((bufPtr != NULL) && ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize)) { - ckfree((char *) bufPtr); - bufPtr = NULL; + if ((bufPtr != NULL) + && (bufPtr->bufLength - BUFFER_PADDING < statePtr->bufSize)) { + ckfree((char *) bufPtr); + bufPtr = NULL; } if (bufPtr == NULL) { bufPtr = AllocChannelBuffer(statePtr->bufSize); } - bufPtr->nextPtr = (ChannelBuffer *) NULL; + bufPtr->nextPtr = (ChannelBuffer *) NULL; /* SF #427196: Use the actual size of the buffer to determine * the number of bytes to read from the channel and not the @@ -5333,12 +5350,12 @@ GetInput(chanPtr) toRead = bufPtr->bufLength - bufPtr->nextAdded; - if (statePtr->inQueueTail == NULL) { - statePtr->inQueueHead = bufPtr; - } else { - statePtr->inQueueTail->nextPtr = bufPtr; - } - statePtr->inQueueTail = bufPtr; + if (statePtr->inQueueTail == NULL) { + statePtr->inQueueHead = bufPtr; + } else { + statePtr->inQueueTail->nextPtr = bufPtr; + } + statePtr->inQueueTail = bufPtr; } /* @@ -5351,23 +5368,26 @@ GetInput(chanPtr) } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* [SF Tcl Bug 943274]. Better emulation of non-blocking channels + /* + * [SF Tcl Bug 943274]. Better emulation of non-blocking channels * for channels without BlockModeProc, by keeping track of true * fileevents generated by the OS == Data waiting and reading if * and only if we are sure to have data. */ if ((statePtr->flags & CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { + /* + * Bypass the driver, it would block, as no data is available + */ - /* Bypass the driver, it would block, as no data is available */ - nread = -1; - result = EWOULDBLOCK; + nread = -1; + result = EWOULDBLOCK; } else { #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData, - bufPtr->buf + bufPtr->nextAdded, toRead, &result); + nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData, + bufPtr->buf + bufPtr->nextAdded, toRead, &result); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ @@ -5381,16 +5401,19 @@ GetInput(chanPtr) * will block in the low level reading code even though the * channel is set into nonblocking mode. */ - + if (nread < toRead) { statePtr->flags |= CHANNEL_BLOCKED; } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING if (nread <= toRead) { - /* [SF Tcl Bug 943274] We have read the available data, - * clear flag */ - statePtr->flags &= ~CHANNEL_HAS_MORE_DATA; + /* + * [SF Tcl Bug 943274] We have read the available data, + * clear flag. + */ + + statePtr->flags &= ~CHANNEL_HAS_MORE_DATA; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ @@ -5439,8 +5462,8 @@ Tcl_Seek(chan, offset, mode) int result; /* Of device driver operations. */ Tcl_WideInt curPos; /* Position on the device. */ int wasAsync; /* Was the channel nonblocking before the - * seek operation? If so, must restore to - * nonblocking mode after the seek. */ + * seek operation? If so, must restore to + * nonblocking mode after the seek. */ if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) { return Tcl_LongAsWide(-1); @@ -5469,8 +5492,8 @@ Tcl_Seek(chan, offset, mode) */ if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { - Tcl_SetErrno(EINVAL); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); } /* @@ -5482,8 +5505,8 @@ Tcl_Seek(chan, offset, mode) outputBuffered = Tcl_OutputBuffered(chan); if ((inputBuffered != 0) && (outputBuffered != 0)) { - Tcl_SetErrno(EFAULT); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(EFAULT); + return Tcl_LongAsWide(-1); } /* @@ -5492,7 +5515,7 @@ Tcl_Seek(chan, offset, mode) */ if (mode == SEEK_CUR) { - offset -= inputBuffered; + offset -= inputBuffered; } /* @@ -5508,8 +5531,8 @@ Tcl_Seek(chan, offset, mode) */ statePtr->flags &= - (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR)); - + ~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR); + /* * If the channel is in asynchronous output mode, switch it back * to synchronous mode and cancel any async flush that may be @@ -5519,15 +5542,15 @@ Tcl_Seek(chan, offset, mode) wasAsync = 0; if (statePtr->flags & CHANNEL_NONBLOCKING) { - wasAsync = 1; - result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); + wasAsync = 1; + result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); if (result != 0) { return Tcl_LongAsWide(-1); } - statePtr->flags &= (~(CHANNEL_NONBLOCKING)); - if (statePtr->flags & BG_FLUSH_SCHEDULED) { - statePtr->flags &= (~(BG_FLUSH_SCHEDULED)); - } + statePtr->flags &= (~(CHANNEL_NONBLOCKING)); + if (statePtr->flags & BG_FLUSH_SCHEDULED) { + statePtr->flags &= (~(BG_FLUSH_SCHEDULED)); + } } /* @@ -5537,7 +5560,7 @@ Tcl_Seek(chan, offset, mode) if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) && (statePtr->curOutPtr->nextAdded > - statePtr->curOutPtr->nextRemoved)) { + statePtr->curOutPtr->nextRemoved)) { statePtr->flags |= BUFFER_READY; } @@ -5548,16 +5571,16 @@ Tcl_Seek(chan, offset, mode) * has already called Tcl_SetErrno() to report the error upwards. * If the flush succeeds we do the seek also. */ - + if (FlushChannel(NULL, chanPtr, 0) != 0) { - curPos = -1; + curPos = -1; } else { - /* - * Now seek to the new position in the channel as requested by the - * caller. Note that we prefer the wideSeekProc if that is + /* + * Now seek to the new position in the channel as requested by the + * caller. Note that we prefer the wideSeekProc if that is * available and non-NULL... - */ + */ if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && chanPtr->typePtr->wideSeekProc != NULL) { @@ -5576,17 +5599,17 @@ Tcl_Seek(chan, offset, mode) Tcl_SetErrno(result); } } - + /* * Restore to nonblocking mode if that was the previous behavior. * * NOTE: Even if there was an async flush active we do not restore * it now because we already flushed all the queued output, above. */ - + if (wasAsync) { - statePtr->flags |= CHANNEL_NONBLOCKING; - result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); + statePtr->flags |= CHANNEL_NONBLOCKING; + result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); if (result != 0) { return Tcl_LongAsWide(-1); } @@ -5651,8 +5674,8 @@ Tcl_Tell(chan) */ if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { - Tcl_SetErrno(EINVAL); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); } /* @@ -5664,8 +5687,8 @@ Tcl_Tell(chan) outputBuffered = Tcl_OutputBuffered(chan); if ((inputBuffered != 0) && (outputBuffered != 0)) { - Tcl_SetErrno(EFAULT); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(EFAULT); + return Tcl_LongAsWide(-1); } /* @@ -5683,11 +5706,11 @@ Tcl_Tell(chan) chanPtr->instanceData, 0, SEEK_CUR, &result)); } if (curPos == Tcl_LongAsWide(-1)) { - Tcl_SetErrno(result); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(result); + return Tcl_LongAsWide(-1); } if (inputBuffered != 0) { - return curPos - inputBuffered; + return curPos - inputBuffered; } return curPos + outputBuffered; } @@ -5751,14 +5774,14 @@ Tcl_TellOld(chan) * *--------------------------------------------------------------------------- */ - + static int 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*/ + * processing */ { int direction = flags & (TCL_READABLE|TCL_WRITABLE); @@ -5767,9 +5790,9 @@ CheckChannelErrors(statePtr, flags) */ if (statePtr->unreportedError != 0) { - Tcl_SetErrno(statePtr->unreportedError); - statePtr->unreportedError = 0; - return -1; + Tcl_SetErrno(statePtr->unreportedError); + statePtr->unreportedError = 0; + return -1; } /* @@ -5779,8 +5802,8 @@ CheckChannelErrors(statePtr, flags) if ((statePtr->flags & CHANNEL_CLOSED) && ((flags & CHANNEL_RAW_MODE) == 0)) { - Tcl_SetErrno(EACCES); - return -1; + Tcl_SetErrno(EACCES); + return -1; } /* @@ -5788,8 +5811,8 @@ CheckChannelErrors(statePtr, flags) */ if ((statePtr->flags & direction) == 0) { - Tcl_SetErrno(EACCES); - return -1; + Tcl_SetErrno(EACCES); + return -1; } /* @@ -5846,8 +5869,8 @@ Tcl_Eof(chan) /* State of real channel structure. */ return ((statePtr->flags & CHANNEL_STICKY_EOF) || - ((statePtr->flags & CHANNEL_EOF) && - (Tcl_InputBuffered(chan) == 0))) ? 1 : 0; + ((statePtr->flags & CHANNEL_EOF) && + (Tcl_InputBuffered(chan) == 0))) ? 1 : 0; } /* @@ -5904,9 +5927,9 @@ Tcl_InputBuffered(chan) int bytesBuffered; for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; - bufPtr != (ChannelBuffer *) NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } /* @@ -5914,9 +5937,9 @@ Tcl_InputBuffered(chan) */ for (bufPtr = statePtr->topChanPtr->inQueueHead; - bufPtr != (ChannelBuffer *) NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } return bytesBuffered; @@ -5942,10 +5965,10 @@ Tcl_InputBuffered(chan) int Tcl_OutputBuffered(chan) - Tcl_Channel chan; /* The channel to query. */ + Tcl_Channel chan; /* The channel to query. */ { ChannelState *statePtr = ((Channel *) chan)->state; - /* State of real channel structure. */ + /* State of real channel structure. */ ChannelBuffer *bufPtr; int bytesBuffered; @@ -5991,9 +6014,9 @@ Tcl_ChannelBuffered(chan) int bytesBuffered; for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead; - bufPtr != (ChannelBuffer *) NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } return bytesBuffered; @@ -6019,21 +6042,21 @@ Tcl_ChannelBuffered(chan) void Tcl_SetChannelBufferSize(chan, sz) Tcl_Channel chan; /* The channel whose buffer size - * to set. */ + * to set. */ int sz; /* The size to set. */ { ChannelState *statePtr; /* State of real channel structure. */ - + /* * If the buffer size is smaller than 10 bytes or larger than one MByte, * do not accept the requested size and leave the current buffer size. */ - + if (sz < 10) { - return; + return; } if (sz > (1024 * 1024)) { - return; + return; } statePtr = ((Channel *) chan)->state; @@ -6068,7 +6091,7 @@ Tcl_SetChannelBufferSize(chan, sz) int Tcl_GetChannelBufferSize(chan) Tcl_Channel chan; /* The channel for which to find the - * buffer size. */ + * buffer size. */ { ChannelState *statePtr = ((Channel *) chan)->state; /* State of real channel structure. */ @@ -6083,9 +6106,9 @@ Tcl_GetChannelBufferSize(chan) * * This procedure generates a "bad option" error message in an * (optional) interpreter. It is used by channel drivers when - * a invalid Set/Get option is requested. Its purpose is to concatenate - * the generic options list to the specific ones and factorize - * the generic options error message string. + * a invalid Set/Get option is requested. Its purpose is to concatenate + * the generic options list to the specific ones and factorize + * the generic options error message string. * * Results: * TCL_ERROR. @@ -6095,11 +6118,11 @@ Tcl_GetChannelBufferSize(chan) * indicate that a command was invoked with the a bad option * The message has the form * bad option "blah": should be one of - * <...generic options...>+<...specific options...> + * <...generic options...>+<...specific options...> * "blah" is the optionName argument and "<specific options>" * is a space separated list of specific option words. - * The function takes good care of inserting minus signs before - * each option, commas after, and an "or" before the last option. + * The function takes good care of inserting minus signs before + * each option, commas after, and an "or" before the last option. * *---------------------------------------------------------------------- */ @@ -6111,8 +6134,7 @@ Tcl_BadChannelOption(interp, optionName, optionList) CONST char *optionList; /* Specific options list to append * to the standard generic options. * can be NULL for generic options - * only. - */ + * only. */ { if (interp) { CONST char *genericopt = @@ -6161,7 +6183,7 @@ Tcl_BadChannelOption(interp, optionName, optionList) * string value of the option(s) returned. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ @@ -6214,54 +6236,53 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) * If the optionName is NULL it means that we want a list of all * options and values. */ - + if (optionName == (char *) NULL) { - len = 0; + len = 0; } else { - len = strlen(optionName); + len = strlen(optionName); } - + if ((len == 0) || ((len > 2) && (optionName[1] == 'b') && - (strncmp(optionName, "-blocking", len) == 0))) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-blocking"); - } - Tcl_DStringAppendElement(dsPtr, + (strncmp(optionName, "-blocking", len) == 0))) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-blocking"); + } + Tcl_DStringAppendElement(dsPtr, (flags & CHANNEL_NONBLOCKING) ? "0" : "1"); - if (len > 0) { - return TCL_OK; - } + if (len > 0) { + return TCL_OK; + } } if ((len == 0) || ((len > 7) && (optionName[1] == 'b') && - (strncmp(optionName, "-buffering", len) == 0))) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-buffering"); - } - if (flags & CHANNEL_LINEBUFFERED) { - Tcl_DStringAppendElement(dsPtr, "line"); - } else if (flags & CHANNEL_UNBUFFERED) { - Tcl_DStringAppendElement(dsPtr, "none"); - } else { - Tcl_DStringAppendElement(dsPtr, "full"); - } - if (len > 0) { - return TCL_OK; - } + (strncmp(optionName, "-buffering", len) == 0))) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-buffering"); + } + if (flags & CHANNEL_LINEBUFFERED) { + Tcl_DStringAppendElement(dsPtr, "line"); + } else if (flags & CHANNEL_UNBUFFERED) { + Tcl_DStringAppendElement(dsPtr, "none"); + } else { + Tcl_DStringAppendElement(dsPtr, "full"); + } + if (len > 0) { + return TCL_OK; + } } if ((len == 0) || ((len > 7) && (optionName[1] == 'b') && - (strncmp(optionName, "-buffersize", len) == 0))) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-buffersize"); - } - TclFormatInt(optionVal, statePtr->bufSize); - Tcl_DStringAppendElement(dsPtr, optionVal); - if (len > 0) { - return TCL_OK; - } - } - if ((len == 0) || - ((len > 2) && (optionName[1] == 'e') && - (strncmp(optionName, "-encoding", len) == 0))) { + (strncmp(optionName, "-buffersize", len) == 0))) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-buffersize"); + } + TclFormatInt(optionVal, statePtr->bufSize); + Tcl_DStringAppendElement(dsPtr, optionVal); + if (len > 0) { + return TCL_OK; + } + } + if ((len == 0) || ((len > 2) && (optionName[1] == 'e') && + (strncmp(optionName, "-encoding", len) == 0))) { if (len == 0) { Tcl_DStringAppendElement(dsPtr, "-encoding"); } @@ -6275,91 +6296,95 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) return TCL_OK; } } - if ((len == 0) || - ((len > 2) && (optionName[1] == 'e') && - (strncmp(optionName, "-eofchar", len) == 0))) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-eofchar"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringStartSublist(dsPtr); - } - if (flags & TCL_READABLE) { - if (statePtr->inEofChar == 0) { - Tcl_DStringAppendElement(dsPtr, ""); - } else { - char buf[4]; - - sprintf(buf, "%c", statePtr->inEofChar); - Tcl_DStringAppendElement(dsPtr, buf); - } - } - if (flags & TCL_WRITABLE) { - if (statePtr->outEofChar == 0) { - Tcl_DStringAppendElement(dsPtr, ""); - } else { - char buf[4]; - - sprintf(buf, "%c", statePtr->outEofChar); - Tcl_DStringAppendElement(dsPtr, buf); - } - } - if ( !(flags & (TCL_READABLE|TCL_WRITABLE))) { - /* Not readable or writable (server socket) */ - Tcl_DStringAppendElement(dsPtr, ""); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringEndSublist(dsPtr); - } - if (len > 0) { - return TCL_OK; - } - } - if ((len == 0) || - ((len > 1) && (optionName[1] == 't') && - (strncmp(optionName, "-translation", len) == 0))) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-translation"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringStartSublist(dsPtr); - } - if (flags & TCL_READABLE) { - if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) { - Tcl_DStringAppendElement(dsPtr, "auto"); - } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) { - Tcl_DStringAppendElement(dsPtr, "cr"); - } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) { - Tcl_DStringAppendElement(dsPtr, "crlf"); - } else { - Tcl_DStringAppendElement(dsPtr, "lf"); - } - } - if (flags & TCL_WRITABLE) { - if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) { - Tcl_DStringAppendElement(dsPtr, "auto"); - } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) { - Tcl_DStringAppendElement(dsPtr, "cr"); - } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) { - Tcl_DStringAppendElement(dsPtr, "crlf"); - } else { - Tcl_DStringAppendElement(dsPtr, "lf"); - } - } - if ( !(flags & (TCL_READABLE|TCL_WRITABLE))) { - /* Not readable or writable (server socket) */ - Tcl_DStringAppendElement(dsPtr, "auto"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringEndSublist(dsPtr); - } - if (len > 0) { - return TCL_OK; - } + if ((len == 0) || ((len > 2) && (optionName[1] == 'e') && + (strncmp(optionName, "-eofchar", len) == 0))) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-eofchar"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringStartSublist(dsPtr); + } + if (flags & TCL_READABLE) { + if (statePtr->inEofChar == 0) { + Tcl_DStringAppendElement(dsPtr, ""); + } else { + char buf[4]; + + sprintf(buf, "%c", statePtr->inEofChar); + Tcl_DStringAppendElement(dsPtr, buf); + } + } + if (flags & TCL_WRITABLE) { + if (statePtr->outEofChar == 0) { + Tcl_DStringAppendElement(dsPtr, ""); + } else { + char buf[4]; + + sprintf(buf, "%c", statePtr->outEofChar); + Tcl_DStringAppendElement(dsPtr, buf); + } + } + if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { + /* + * Not readable or writable (e.g. server socket) + */ + + Tcl_DStringAppendElement(dsPtr, ""); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringEndSublist(dsPtr); + } + if (len > 0) { + return TCL_OK; + } + } + if ((len == 0) || ((len > 1) && (optionName[1] == 't') && + (strncmp(optionName, "-translation", len) == 0))) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-translation"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringStartSublist(dsPtr); + } + if (flags & TCL_READABLE) { + if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) { + Tcl_DStringAppendElement(dsPtr, "auto"); + } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) { + Tcl_DStringAppendElement(dsPtr, "cr"); + } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) { + Tcl_DStringAppendElement(dsPtr, "crlf"); + } else { + Tcl_DStringAppendElement(dsPtr, "lf"); + } + } + if (flags & TCL_WRITABLE) { + if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) { + Tcl_DStringAppendElement(dsPtr, "auto"); + } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) { + Tcl_DStringAppendElement(dsPtr, "cr"); + } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) { + Tcl_DStringAppendElement(dsPtr, "crlf"); + } else { + Tcl_DStringAppendElement(dsPtr, "lf"); + } + } + if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { + /* + * Not readable or writable (e.g. server socket) + */ + + Tcl_DStringAppendElement(dsPtr, "auto"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringEndSublist(dsPtr); + } + if (len > 0) { + return TCL_OK; + } } if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) { /* @@ -6367,16 +6392,16 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) * and result code and message. */ - return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData, + return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData, interp, optionName, dsPtr); } else { /* * no driver specific options case. */ - if (len == 0) { - return TCL_OK; - } + if (len == 0) { + return TCL_OK; + } return Tcl_BadChannelOption(interp, optionName, NULL); } } @@ -6417,11 +6442,10 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) if (statePtr->csPtr) { if (interp) { - Tcl_AppendResult(interp, - "unable to set channel options: background copy in progress", - (char *) NULL); + Tcl_AppendResult(interp, "unable to set channel options: ", + "background copy in progress", (char *) NULL); } - return TCL_ERROR; + return TCL_ERROR; } /* @@ -6444,47 +6468,47 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) len = strlen(optionName); if ((len > 2) && (optionName[1] == 'b') && - (strncmp(optionName, "-blocking", len) == 0)) { + (strncmp(optionName, "-blocking", len) == 0)) { int newMode; - if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) { - return TCL_ERROR; - } - if (newMode) { - newMode = TCL_MODE_BLOCKING; - } else { - newMode = TCL_MODE_NONBLOCKING; - } + if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) { + return TCL_ERROR; + } + if (newMode) { + newMode = TCL_MODE_BLOCKING; + } else { + newMode = TCL_MODE_NONBLOCKING; + } return SetBlockMode(interp, chanPtr, newMode); } else if ((len > 7) && (optionName[1] == 'b') && - (strncmp(optionName, "-buffering", len) == 0)) { - len = strlen(newValue); - if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) { - statePtr->flags &= - (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED)); - } else if ((newValue[0] == 'l') && - (strncmp(newValue, "line", len) == 0)) { - statePtr->flags &= (~(CHANNEL_UNBUFFERED)); - statePtr->flags |= CHANNEL_LINEBUFFERED; - } else if ((newValue[0] == 'n') && - (strncmp(newValue, "none", len) == 0)) { - statePtr->flags &= (~(CHANNEL_LINEBUFFERED)); - statePtr->flags |= CHANNEL_UNBUFFERED; - } else { - if (interp) { - Tcl_AppendResult(interp, "bad value for -buffering: ", - "must be one of full, line, or none", - (char *) NULL); - return TCL_ERROR; - } - } + (strncmp(optionName, "-buffering", len) == 0)) { + len = strlen(newValue); + if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) { + statePtr->flags &= + (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED)); + } else if ((newValue[0] == 'l') && + (strncmp(newValue, "line", len) == 0)) { + statePtr->flags &= (~(CHANNEL_UNBUFFERED)); + statePtr->flags |= CHANNEL_LINEBUFFERED; + } else if ((newValue[0] == 'n') && + (strncmp(newValue, "none", len) == 0)) { + statePtr->flags &= (~(CHANNEL_LINEBUFFERED)); + statePtr->flags |= CHANNEL_UNBUFFERED; + } else { + if (interp) { + Tcl_AppendResult(interp, "bad value for -buffering: ", + "must be one of full, line, or none", + (char *) NULL); + return TCL_ERROR; + } + } return TCL_OK; } else if ((len > 7) && (optionName[1] == 'b') && - (strncmp(optionName, "-buffersize", len) == 0)) { + (strncmp(optionName, "-buffersize", len) == 0)) { int newBufferSize; if (Tcl_GetInt(interp, newValue, &newBufferSize) == TCL_ERROR) { return TCL_ERROR; } - Tcl_SetChannelBufferSize(chan, newBufferSize); + Tcl_SetChannelBufferSize(chan, newBufferSize); } else if ((len > 2) && (optionName[1] == 'e') && (strncmp(optionName, "-encoding", len) == 0)) { Tcl_Encoding encoding; @@ -6497,10 +6521,12 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) return TCL_ERROR; } } + /* * When the channel has an escape sequence driven encoding such as * iso2022, the terminated escape sequence must write to the buffer. */ + if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL) && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) { statePtr->outputEncodingFlags |= TCL_ENCODING_END; @@ -6515,39 +6541,39 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) statePtr->flags &= ~CHANNEL_NEED_MORE_DATA; UpdateInterest(chanPtr); } else if ((len > 2) && (optionName[1] == 'e') && - (strncmp(optionName, "-eofchar", len) == 0)) { - if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { - return TCL_ERROR; - } - if (argc == 0) { - statePtr->inEofChar = 0; - statePtr->outEofChar = 0; - } else if (argc == 1) { - if (statePtr->flags & TCL_WRITABLE) { - statePtr->outEofChar = (int) argv[0][0]; - } - if (statePtr->flags & TCL_READABLE) { - statePtr->inEofChar = (int) argv[0][0]; - } - } else if (argc != 2) { - if (interp) { - Tcl_AppendResult(interp, - "bad value for -eofchar: should be a list of zero,", - " one, or two elements", (char *) NULL); - } - ckfree((char *) argv); - return TCL_ERROR; - } else { - if (statePtr->flags & TCL_READABLE) { - statePtr->inEofChar = (int) argv[0][0]; - } - if (statePtr->flags & TCL_WRITABLE) { - statePtr->outEofChar = (int) argv[1][0]; - } - } - if (argv != NULL) { - ckfree((char *) argv); - } + (strncmp(optionName, "-eofchar", len) == 0)) { + if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { + return TCL_ERROR; + } + if (argc == 0) { + statePtr->inEofChar = 0; + statePtr->outEofChar = 0; + } else if (argc == 1) { + if (statePtr->flags & TCL_WRITABLE) { + statePtr->outEofChar = (int) argv[0][0]; + } + if (statePtr->flags & TCL_READABLE) { + statePtr->inEofChar = (int) argv[0][0]; + } + } else if (argc != 2) { + if (interp) { + Tcl_AppendResult(interp, + "bad value for -eofchar: should be a list of zero,", + " one, or two elements", (char *) NULL); + } + ckfree((char *) argv); + return TCL_ERROR; + } else { + if (statePtr->flags & TCL_READABLE) { + statePtr->inEofChar = (int) argv[0][0]; + } + if (statePtr->flags & TCL_WRITABLE) { + statePtr->outEofChar = (int) argv[1][0]; + } + } + if (argv != NULL) { + ckfree((char *) argv); + } /* * [SF Tcl Bug 930851] Reset EOF and BLOCKED flags. Changing @@ -6555,31 +6581,32 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) * condition into a 'go ahead'. Ditto for blocked. */ - statePtr->flags &= (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED)); + statePtr->flags &= + ~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED); return TCL_OK; } else if ((len > 1) && (optionName[1] == 't') && - (strncmp(optionName, "-translation", len) == 0)) { + (strncmp(optionName, "-translation", len) == 0)) { CONST char *readMode, *writeMode; - if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { - return TCL_ERROR; - } + if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { + return TCL_ERROR; + } - if (argc == 1) { + if (argc == 1) { readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL; writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL; } else if (argc == 2) { readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL; writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[1] : NULL; } else { - if (interp) { - Tcl_AppendResult(interp, - "bad value for -translation: must be a one or two", - " element list", (char *) NULL); - } - ckfree((char *) argv); - return TCL_ERROR; + if (interp) { + Tcl_AppendResult(interp, + "bad value for -translation: must be a one or two", + " element list", (char *) NULL); + } + ckfree((char *) argv); + return TCL_ERROR; } if (readMode) { @@ -6665,11 +6692,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) return TCL_ERROR; } } - ckfree((char *) argv); - return TCL_OK; + ckfree((char *) argv); + return TCL_OK; } else if (chanPtr->typePtr->setOptionProc != NULL) { - return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData, - interp, optionName, newValue); + return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData, + interp, optionName, newValue); } else { return Tcl_BadChannelOption(interp, optionName, (char *) NULL); } @@ -6739,27 +6766,27 @@ CleanupChannelHandlers(interp, chanPtr) * Remove fileevent records on this channel that refer to the * given interpreter. */ - + 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_DecrRefCount(sPtr->scriptPtr); - ckfree((char *) sPtr); - } else { - prevPtr = sPtr; - } + 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); + + TclDecrRefCount(sPtr->scriptPtr); + ckfree((char *) sPtr); + } else { + prevPtr = sPtr; + } } } @@ -6794,8 +6821,8 @@ Tcl_NotifyChannel(channel, mask) ChannelHandler *chPtr; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); NextChannelHandler nh; - Channel* upChanPtr; - Tcl_ChannelType* upTypePtr; + Channel *upChanPtr; + Tcl_ChannelType *upTypePtr; #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING /* [SF Tcl Bug 943274] @@ -6805,11 +6832,11 @@ Tcl_NotifyChannel(channel, mask) */ if ((mask & TCL_READABLE) && - (statePtr->flags & CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !(statePtr->flags & CHANNEL_TIMER_FEV)) { + (statePtr->flags & CHANNEL_NONBLOCKING) && + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_TIMER_FEV)) { - statePtr->flags |= CHANNEL_HAS_MORE_DATA; + statePtr->flags |= CHANNEL_HAS_MORE_DATA; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ @@ -6825,10 +6852,10 @@ Tcl_NotifyChannel(channel, mask) * generate their own events and pass them upward. */ - while (mask && (chanPtr->upChanPtr != ((Channel*) NULL))) { - Tcl_DriverHandlerProc* upHandlerProc; + while (mask && (chanPtr->upChanPtr != ((Channel *) NULL))) { + Tcl_DriverHandlerProc *upHandlerProc; - upChanPtr = chanPtr->upChanPtr; + upChanPtr = chanPtr->upChanPtr; upTypePtr = upChanPtr->typePtr; upHandlerProc = Tcl_ChannelHandlerProc(upTypePtr); if (upHandlerProc != NULL) { @@ -6852,7 +6879,7 @@ Tcl_NotifyChannel(channel, mask) */ if (!mask) { - return; + return; } /* @@ -6861,7 +6888,7 @@ Tcl_NotifyChannel(channel, mask) * * Preserve the channel struct in case the script closes it. */ - + Tcl_Preserve((ClientData) channel); Tcl_Preserve((ClientData) statePtr); @@ -6881,7 +6908,7 @@ Tcl_NotifyChannel(channel, mask) * Add this invocation to the list of recursive invocations of * ChannelHandlerEventProc. */ - + nh.nextHandlerPtr = (ChannelHandler *) NULL; nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr; tsdPtr->nestedHandlerPtr = &nh; @@ -6908,7 +6935,7 @@ Tcl_NotifyChannel(channel, mask) */ if (chanPtr->typePtr != NULL) { - UpdateInterest(chanPtr); + UpdateInterest(chanPtr); } Tcl_Release((ClientData) statePtr); @@ -7109,7 +7136,7 @@ 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. */ @@ -7125,21 +7152,21 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData) */ for (chPtr = statePtr->chPtr; - chPtr != (ChannelHandler *) NULL; - chPtr = chPtr->nextPtr) { - if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) && - (chPtr->clientData == clientData)) { - break; - } + 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 = statePtr->chPtr; - statePtr->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; } /* @@ -7154,11 +7181,11 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData) * Recompute the interest mask for the channel - this call may actually * be disabling an existing handler. */ - + statePtr->interestMask = 0; for (chPtr = statePtr->chPtr; - chPtr != (ChannelHandler *) NULL; - chPtr = chPtr->nextPtr) { + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { statePtr->interestMask |= chPtr->mask; } @@ -7187,11 +7214,10 @@ 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. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ChannelHandler *chPtr, *prevChPtr; @@ -7204,13 +7230,13 @@ Tcl_DeleteChannelHandler(chan, proc, clientData) */ 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; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { + if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData) + && (chPtr->proc == proc)) { + break; + } + prevChPtr = chPtr; } /* @@ -7218,7 +7244,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData) */ if (chPtr == (ChannelHandler *) NULL) { - return; + return; } /* @@ -7227,21 +7253,21 @@ 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; + } } /* * Splice it out of the list of channel handlers. */ - + if (prevChPtr == (ChannelHandler *) NULL) { - statePtr->chPtr = chPtr->nextPtr; + statePtr->chPtr = chPtr->nextPtr; } else { - prevChPtr->nextPtr = chPtr->nextPtr; + prevChPtr->nextPtr = chPtr->nextPtr; } ckfree((char *) chPtr); @@ -7253,9 +7279,9 @@ Tcl_DeleteChannelHandler(chan, proc, clientData) statePtr->interestMask = 0; for (chPtr = statePtr->chPtr; - chPtr != (ChannelHandler *) NULL; - chPtr = chPtr->nextPtr) { - statePtr->interestMask |= chPtr->mask; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { + statePtr->interestMask |= chPtr->mask; } UpdateInterest(statePtr->topChanPtr); @@ -7281,34 +7307,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 = 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_DecrRefCount(esPtr->scriptPtr); - ckfree((char *) esPtr); - - break; - } + 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); + + TclDecrRefCount(esPtr->scriptPtr); + ckfree((char *) esPtr); + + break; + } } } @@ -7332,32 +7358,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 = statePtr->scriptRecordPtr; - esPtr != (EventScriptRecord *) NULL; - esPtr = esPtr->nextPtr) { - if ((esPtr->interp == interp) && (esPtr->mask == mask)) { - Tcl_DecrRefCount(esPtr->scriptPtr); + esPtr != (EventScriptRecord *) NULL; + esPtr = esPtr->nextPtr) { + if ((esPtr->interp == interp) && (esPtr->mask == mask)) { + TclDecrRefCount(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 = statePtr->scriptRecordPtr; - statePtr->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; @@ -7391,9 +7417,9 @@ 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; @@ -7406,7 +7432,7 @@ TclChannelEventScriptInvoker(clientData, mask) * later. Note that we do not need to preserve the channel because * that is done by Tcl_NotifyChannel before calling channel handlers. */ - + Tcl_Preserve((ClientData) interp); result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL); @@ -7417,12 +7443,12 @@ TclChannelEventScriptInvoker(clientData, mask) * NOTE: Must delete channel handler before causing the background error * because the background error may want to reinstall the handler. */ - + if (result != TCL_OK) { if (chanPtr->typePtr != NULL) { DeleteScriptRecord(interp, chanPtr, mask); } - Tcl_BackgroundError(interp); + Tcl_BackgroundError(interp); } Tcl_Release((ClientData) interp); } @@ -7451,13 +7477,13 @@ 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; @@ -7481,15 +7507,15 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv) if (chan == (Tcl_Channel) NULL) { return TCL_ERROR; } - chanPtr = (Channel *) chan; + 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; + Tcl_AppendResult(interp, "channel is not ", + (mask == TCL_READABLE) ? "readable" : "writable", + (char *) NULL); + return TCL_ERROR; } - + /* * If we are supposed to return the script, do so. */ @@ -7497,14 +7523,14 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv) if (objc == 3) { EventScriptRecord *esPtr; for (esPtr = statePtr->scriptRecordPtr; - esPtr != (EventScriptRecord *) NULL; - esPtr = esPtr->nextPtr) { + 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; } /* @@ -7512,8 +7538,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; } /* @@ -7523,7 +7549,7 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv) */ CreateScriptRecord(interp, chanPtr, mask, objv[3]); - + return TCL_OK; } @@ -7563,8 +7589,8 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) CopyState *csPtr; int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0; - inStatePtr = inPtr->state; - outStatePtr = outPtr->state; + inStatePtr = inPtr->state; + outStatePtr = outPtr->state; if (inStatePtr->csPtr) { Tcl_AppendResult(interp, "channel \"", @@ -7577,8 +7603,8 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) return TCL_ERROR; } - readFlags = inStatePtr->flags; - writeFlags = outStatePtr->flags; + readFlags = inStatePtr->flags; + writeFlags = outStatePtr->flags; /* * Set up the blocking mode appropriately. Background copies need @@ -7621,15 +7647,15 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) * completed. */ - csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inStatePtr->bufSize); - csPtr->bufSize = inStatePtr->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); } @@ -7671,7 +7697,7 @@ CopyData(csPtr, mask) Tcl_Channel inChan, outChan; ChannelState *inStatePtr, *outStatePtr; int result = TCL_OK, size, total, sizeb; - char* buffer; + char *buffer; int inBinary, outBinary, sameEncoding; /* Encoding control */ int underflow; /* input underflow */ @@ -7691,13 +7717,13 @@ CopyData(csPtr, mask) * thus gets the bottom of the stack. */ - inBinary = (inStatePtr->encoding == NULL); - outBinary = (outStatePtr->encoding == NULL); - sameEncoding = (inStatePtr->encoding == outStatePtr->encoding); + inBinary = (inStatePtr->encoding == NULL); + outBinary = (outStatePtr->encoding == NULL); + sameEncoding = (inStatePtr->encoding == outStatePtr->encoding); if (!(inBinary || sameEncoding)) { - bufObj = Tcl_NewObj (); - Tcl_IncrRefCount (bufObj); + TclNewObj(bufObj); + Tcl_IncrRefCount(bufObj); } while (csPtr->toRead != 0) { @@ -7715,7 +7741,7 @@ CopyData(csPtr, mask) outStatePtr->unreportedError = 0; goto writeError; } - + /* * Read up to bufSize bytes. */ @@ -7735,7 +7761,7 @@ CopyData(csPtr, mask) if (size < 0) { readError: - errObj = Tcl_NewObj(); + TclNewObj(errObj); Tcl_AppendStringsToObj(errObj, "error reading \"", Tcl_GetChannelName(inChan), "\": ", Tcl_PosixError(interp), (char *) NULL); @@ -7746,7 +7772,7 @@ CopyData(csPtr, mask) * then the copying is done, otherwise set up a channel * handler to detect when the channel becomes readable again. */ - + if ((size == 0) && Tcl_Eof(inChan)) { break; } @@ -7759,9 +7785,9 @@ CopyData(csPtr, mask) CopyEventProc, (ClientData) csPtr); } if (size == 0) { - if (bufObj != (Tcl_Obj*) NULL) { - Tcl_DecrRefCount (bufObj); - bufObj = (Tcl_Obj*) NULL; + if (bufObj != (Tcl_Obj *) NULL) { + TclDecrRefCount(bufObj); + bufObj = (Tcl_Obj *) NULL; } return TCL_OK; } @@ -7775,7 +7801,7 @@ CopyData(csPtr, mask) buffer = csPtr->buffer; sizeb = size; } else { - buffer = Tcl_GetStringFromObj (bufObj, &sizeb); + buffer = Tcl_GetStringFromObj(bufObj, &sizeb); } if (outBinary || sameEncoding) { @@ -7791,7 +7817,7 @@ CopyData(csPtr, mask) if (sizeb < 0) { writeError: - errObj = Tcl_NewObj(); + TclNewObj(errObj); Tcl_AppendStringsToObj(errObj, "error writing \"", Tcl_GetChannelName(outChan), "\": ", Tcl_PosixError(interp), (char *) NULL); @@ -7814,9 +7840,9 @@ CopyData(csPtr, mask) * Break loop if EOF && (size>0) */ - if (Tcl_Eof(inChan)) { - break; - } + if (Tcl_Eof(inChan)) { + break; + } /* * Check to see if the write is happening in the background. If so, @@ -7825,7 +7851,7 @@ CopyData(csPtr, mask) * therefore we don't need a writable handler. */ - if ( ! underflow && (outStatePtr->flags & BG_FLUSH_SCHEDULED) ) { + if (!underflow && (outStatePtr->flags & BG_FLUSH_SCHEDULED)) { if (!(mask & TCL_WRITABLE)) { if (mask & TCL_READABLE) { Tcl_DeleteChannelHandler(inChan, CopyEventProc, @@ -7834,9 +7860,9 @@ CopyData(csPtr, mask) Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc, (ClientData) csPtr); } - if (bufObj != (Tcl_Obj*) NULL) { - Tcl_DecrRefCount (bufObj); - bufObj = (Tcl_Obj*) NULL; + if (bufObj != (Tcl_Obj *) NULL) { + TclDecrRefCount(bufObj); + bufObj = (Tcl_Obj *) NULL; } return TCL_OK; } @@ -7856,17 +7882,17 @@ CopyData(csPtr, mask) Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc, (ClientData) csPtr); } - if (bufObj != (Tcl_Obj*) NULL) { - Tcl_DecrRefCount (bufObj); - bufObj = (Tcl_Obj*) NULL; + if (bufObj != (Tcl_Obj *) NULL) { + TclDecrRefCount(bufObj); + bufObj = (Tcl_Obj *) NULL; } return TCL_OK; } } /* while */ - if (bufObj != (Tcl_Obj*) NULL) { - Tcl_DecrRefCount (bufObj); - bufObj = (Tcl_Obj*) NULL; + if (bufObj != (Tcl_Obj *) NULL) { + TclDecrRefCount(bufObj); + bufObj = (Tcl_Obj *) NULL; } /* @@ -7895,7 +7921,7 @@ CopyData(csPtr, mask) Tcl_BackgroundError(interp); result = TCL_ERROR; } - Tcl_DecrRefCount(cmdPtr); + TclDecrRefCount(cmdPtr); Tcl_Release((ClientData) interp); } else { StopCopy(csPtr); @@ -7937,9 +7963,9 @@ DoRead(chanPtr, bufPtr, toRead) { 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. */ /* @@ -7949,31 +7975,31 @@ DoRead(chanPtr, bufPtr, toRead) */ if (!(statePtr->flags & CHANNEL_STICKY_EOF)) { - statePtr->flags &= ~CHANNEL_EOF; + statePtr->flags &= ~CHANNEL_EOF; } statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA); - + for (copied = 0; copied < toRead; copied += copiedNow) { - copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied, - toRead - copied); - if (copiedNow == 0) { - if (statePtr->flags & CHANNEL_EOF) { + copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied, + toRead - copied); + if (copiedNow == 0) { + if (statePtr->flags & CHANNEL_EOF) { goto done; - } - if (statePtr->flags & CHANNEL_BLOCKED) { - if (statePtr->flags & CHANNEL_NONBLOCKING) { + } + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { goto done; - } - statePtr->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; - } - } + } + } } statePtr->flags &= (~(CHANNEL_BLOCKED)); @@ -8012,39 +8038,39 @@ 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? */ + * 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? */ + * copied in the current input buffer? */ int copied; /* How many characters were already copied - * into the destination space? */ + * into the destination space? */ int i; /* Iterates over the copied input looking - * for the input eofChar. */ - + * for the input eofChar. */ + /* * 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 leave it in the queue. */ - + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { - return 0; + return 0; } bufPtr = statePtr->inQueueHead; bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved; copied = 0; switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: { - if (bytesInBuffer == 0) { - return 0; - } + case TCL_TRANSLATE_LF: { + if (bytesInBuffer == 0) { + return 0; + } /* - * Copy the current chunk into the result buffer. - */ + * Copy the current chunk into the result buffer. + */ if (bytesInBuffer < space) { space = bytesInBuffer; @@ -8054,19 +8080,19 @@ CopyAndTranslateBuffer(statePtr, result, space) (size_t) space); bufPtr->nextRemoved += space; copied = space; - break; + break; } - case TCL_TRANSLATE_CR: { + case TCL_TRANSLATE_CR: { char *end; - - if (bytesInBuffer == 0) { - return 0; - } + + if (bytesInBuffer == 0) { + return 0; + } /* - * Copy the current chunk into the result buffer, then - * replace all \r with \n. - */ + * Copy the current chunk into the result buffer, then + * replace all \r with \n. + */ if (bytesInBuffer < space) { space = bytesInBuffer; @@ -8081,31 +8107,31 @@ CopyAndTranslateBuffer(statePtr, result, space) if (*result == '\r') { *result = '\n'; } - } - break; + } + break; } - case TCL_TRANSLATE_CRLF: { + case TCL_TRANSLATE_CRLF: { char *src, *end, *dst; int curByte; - - /* - * If there is a held-back "\r" at EOF, produce it now. - */ - + + /* + * If there is a held-back "\r" at EOF, produce it now. + */ + if (bytesInBuffer == 0) { - if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) == - (INPUT_SAW_CR | CHANNEL_EOF)) { - result[0] = '\r'; - statePtr->flags &= ~INPUT_SAW_CR; - return 1; - } - return 0; - } - - /* - * Copy the current chunk and replace "\r\n" with "\n" - * (but not standalone "\r"!). - */ + if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) == + (INPUT_SAW_CR | CHANNEL_EOF)) { + result[0] = '\r'; + statePtr->flags &= ~INPUT_SAW_CR; + return 1; + } + return 0; + } + + /* + * Copy the current chunk and replace "\r\n" with "\n" + * (but not standalone "\r"!). + */ if (bytesInBuffer < space) { space = bytesInBuffer; @@ -8121,7 +8147,7 @@ CopyAndTranslateBuffer(statePtr, result, space) for (src = result; src < end; src++) { curByte = *src; if (curByte == '\n') { - statePtr->flags &= ~INPUT_SAW_CR; + statePtr->flags &= ~INPUT_SAW_CR; } else if (statePtr->flags & INPUT_SAW_CR) { statePtr->flags &= ~INPUT_SAW_CR; *dst = '\r'; @@ -8137,18 +8163,18 @@ CopyAndTranslateBuffer(statePtr, result, space) copied = dst - result; break; } - case TCL_TRANSLATE_AUTO: { + case TCL_TRANSLATE_AUTO: { char *src, *end, *dst; int curByte; - - if (bytesInBuffer == 0) { - return 0; - } - /* - * Loop over the current buffer, converting "\r" and "\r\n" - * to "\n". - */ + if (bytesInBuffer == 0) { + return 0; + } + + /* + * Loop over the current buffer, converting "\r" and "\r\n" + * to "\n". + */ if (bytesInBuffer < space) { space = bytesInBuffer; @@ -8177,10 +8203,10 @@ CopyAndTranslateBuffer(statePtr, result, space) } } copied = dst - result; - break; + break; } - default: { - Tcl_Panic("unknown eol translation mode"); + default: { + Tcl_Panic("unknown eol translation mode"); } } @@ -8189,21 +8215,21 @@ CopyAndTranslateBuffer(statePtr, result, space) * the input we copied so far does not contain the EOF char. If it does, * copy only up to and excluding that character. */ - + if (statePtr->inEofChar != 0) { - for (i = 0; i < copied; i++) { - if (result[i] == (char) statePtr->inEofChar) { + for (i = 0; i < copied; i++) { + if (result[i] == (char) statePtr->inEofChar) { /* * Set sticky EOF so that no further input is presented * to the caller. */ - + statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); statePtr->inputEncodingFlags |= TCL_ENCODING_END; copied = i; - break; - } - } + break; + } + } } /* @@ -8211,11 +8237,11 @@ CopyAndTranslateBuffer(statePtr, result, space) */ if (bufPtr->nextRemoved == bufPtr->nextAdded) { - statePtr->inQueueHead = bufPtr->nextPtr; - if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { - statePtr->inQueueTail = (ChannelBuffer *) NULL; - } - RecycleBuffer(statePtr, bufPtr, 0); + statePtr->inQueueHead = bufPtr->nextPtr; + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { + statePtr->inQueueTail = (ChannelBuffer *) NULL; + } + RecycleBuffer(statePtr, bufPtr, 0); } /* @@ -8249,14 +8275,14 @@ 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? */ + * 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? */ + * copied in the current input buffer? */ int copied; /* How many characters were already copied - * into the destination space? */ - + * 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 @@ -8264,9 +8290,9 @@ CopyBuffer(chanPtr, result, space) * 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; + return 0; } bufPtr = chanPtr->inQueueHead; bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved; @@ -8274,10 +8300,10 @@ CopyBuffer(chanPtr, result, space) copied = 0; if (bytesInBuffer == 0) { - RecycleBuffer(chanPtr->state, bufPtr, 0); - chanPtr->inQueueHead = (ChannelBuffer*) NULL; - chanPtr->inQueueTail = (ChannelBuffer*) NULL; - return 0; + RecycleBuffer(chanPtr->state, bufPtr, 0); + chanPtr->inQueueHead = (ChannelBuffer *) NULL; + chanPtr->inQueueTail = (ChannelBuffer *) NULL; + return 0; } /* @@ -8285,7 +8311,7 @@ CopyBuffer(chanPtr, result, space) */ if (bytesInBuffer < space) { - space = bytesInBuffer; + space = bytesInBuffer; } memcpy((VOID *) result, @@ -8305,11 +8331,11 @@ CopyBuffer(chanPtr, result, space) */ if (bufPtr->nextRemoved == bufPtr->nextAdded) { - chanPtr->inQueueHead = bufPtr->nextPtr; - if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { - chanPtr->inQueueTail = (ChannelBuffer *) NULL; - } - RecycleBuffer(chanPtr->state, bufPtr, 0); + chanPtr->inQueueHead = bufPtr->nextPtr; + if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { + chanPtr->inQueueTail = (ChannelBuffer *) NULL; + } + RecycleBuffer(chanPtr->state, bufPtr, 0); } /* @@ -8352,17 +8378,17 @@ DoWrite(chanPtr, src, srcLen) char *dPtr; CONST 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? */ /* @@ -8371,7 +8397,7 @@ DoWrite(chanPtr, src, srcLen) */ crsent = 0; - + /* * Loop filling buffers and flushing them until all output has been * consumed. @@ -8381,97 +8407,97 @@ DoWrite(chanPtr, src, srcLen) totalDestCopied = 0; while (srcLen > 0) { - - /* - * Make sure there is a current output buffer to accept output. - */ - - if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { - statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize); - } - - outBufPtr = statePtr->curOutPtr; - - 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: - Tcl_Panic("Tcl_Write: AUTO output translation mode not supported"); - default: - Tcl_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. - */ - - 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) { - statePtr->flags |= BUFFER_READY; - } - } else if (statePtr->flags & CHANNEL_UNBUFFERED) { - statePtr->flags |= BUFFER_READY; - } - } - - totalDestCopied += srcCopied; - src += srcCopied; - srcLen -= srcCopied; - - if (statePtr->flags & BUFFER_READY) { - if (FlushChannel(NULL, chanPtr, 0) != 0) { - return -1; - } - } + + /* + * Make sure there is a current output buffer to accept output. + */ + + if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { + statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize); + } + + outBufPtr = statePtr->curOutPtr; + + 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: + Tcl_Panic("Tcl_Write: AUTO output translation mode not supported"); + default: + Tcl_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. + */ + + 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) { + statePtr->flags |= BUFFER_READY; + } + } else if (statePtr->flags & CHANNEL_UNBUFFERED) { + statePtr->flags |= BUFFER_READY; + } + } + + totalDestCopied += srcCopied; + src += srcCopied; + srcLen -= srcCopied; + + if (statePtr->flags & BUFFER_READY) { + if (FlushChannel(NULL, chanPtr, 0) != 0) { + return -1; + } + } } /* Closes "while" */ return totalDestCopied; @@ -8531,8 +8557,8 @@ StopCopy(csPtr) return; } - inStatePtr = csPtr->readPtr->state; - outStatePtr = csPtr->writePtr->state; + inStatePtr = csPtr->readPtr->state; + outStatePtr = csPtr->writePtr->state; /* * Restore the old blocking mode and output buffering mode. @@ -8561,11 +8587,11 @@ StopCopy(csPtr) Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr, CopyEventProc, (ClientData)csPtr); } - Tcl_DecrRefCount(csPtr->cmdPtr); + TclDecrRefCount(csPtr->cmdPtr); } - inStatePtr->csPtr = NULL; + inStatePtr->csPtr = NULL; outStatePtr->csPtr = NULL; - ckfree((char*) csPtr); + ckfree((char *) csPtr); } /* @@ -8720,15 +8746,16 @@ Tcl_GetChannelNamesEx(interp, pattern) * Get the channel table that stores the channels registered * for this interpreter. */ - hTblPtr = GetChannelTable(interp); - resultPtr = Tcl_NewObj(); + + hTblPtr = GetChannelTable(interp); + TclNewObj(resultPtr); for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); - hPtr != (Tcl_HashEntry *) NULL; - hPtr = Tcl_NextHashEntry(&hSearch)) { + hPtr != (Tcl_HashEntry *) NULL; + hPtr = Tcl_NextHashEntry(&hSearch)) { statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state; - if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { + if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { name = "stdin"; } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) { name = "stdout"; @@ -8739,13 +8766,14 @@ Tcl_GetChannelNamesEx(interp, pattern) * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), * but it's simpler to just grab the name from the statePtr. */ + name = statePtr->channelName; } if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) && (Tcl_ListObjAppendElement(interp, resultPtr, Tcl_NewStringObj(name, -1)) != TCL_OK)) { - Tcl_DecrRefCount(resultPtr); + TclDecrRefCount(resultPtr); return TCL_ERROR; } } @@ -8771,8 +8799,8 @@ Tcl_GetChannelNamesEx(interp, pattern) */ int -Tcl_IsChannelRegistered (interp, chan) - Tcl_Interp* interp; /* The interp to query of the channel */ +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. */ @@ -8784,19 +8812,20 @@ Tcl_IsChannelRegistered (interp, chan) * 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; + return 0; } hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName); if (hPtr == (Tcl_HashEntry *) NULL) { - return 0; + return 0; } if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { - return 0; + return 0; } return 1; @@ -8819,8 +8848,8 @@ Tcl_IsChannelRegistered (interp, chan) */ int -Tcl_IsChannelShared (chan) - Tcl_Channel chan; /* The channel to query */ +Tcl_IsChannelShared(chan) + Tcl_Channel chan; /* The channel to query */ { ChannelState *statePtr = ((Channel *) chan)->state; /* State of real channel structure. */ @@ -8848,7 +8877,7 @@ Tcl_IsChannelShared (chan) int Tcl_IsChannelExisting(chanName) - CONST char* chanName; /* The name of the channel to look for. */ + CONST char *chanName; /* The name of the channel to look for. */ { ChannelState *statePtr; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); @@ -8857,9 +8886,9 @@ Tcl_IsChannelExisting(chanName) chanNameLen = strlen(chanName); for (statePtr = tsdPtr->firstCSPtr; - statePtr != NULL; - statePtr = statePtr->nextCSPtr) { - if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { + statePtr != NULL; + statePtr = statePtr->nextCSPtr) { + if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { name = "stdin"; } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) { name = "stdout"; @@ -8930,6 +8959,7 @@ Tcl_ChannelVersion(chanTypePtr) * In <v2 channel versions, the version field is occupied * by the Tcl_DriverBlockModeProc */ + return TCL_CHANNEL_VERSION_1; } } @@ -8986,6 +9016,7 @@ Tcl_ChannelBlockModeProc(chanTypePtr) /* * The v1 structure had the blockModeProc in a different place. */ + return (Tcl_DriverBlockModeProc *) (chanTypePtr->version); } } @@ -9277,43 +9308,44 @@ Tcl_ChannelWideSeekProc(chanTypePtr) return NULL; } } - + #if 0 -/* For future debugging work, a simple function to print the flags of +/* + * For future debugging work, a simple function to print the flags of * a channel in semi-readable form. */ static int -DumpFlags (str, flags) - char* str; +DumpFlags(str, flags) + char *str; int flags; { - char buf [20]; - int i = 0; - - if (flags & TCL_READABLE) {buf[i] = 'r';} else {buf [i]='_';}; i++; - if (flags & TCL_WRITABLE) {buf[i] = 'w';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_NONBLOCKING) {buf[i] = 'n';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_LINEBUFFERED) {buf[i] = 'l';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_UNBUFFERED) {buf[i] = 'u';} else {buf [i]='_';}; i++; - if (flags & BUFFER_READY) {buf[i] = 'R';} else {buf [i]='_';}; i++; - if (flags & BG_FLUSH_SCHEDULED) {buf[i] = 'F';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_CLOSED) {buf[i] = 'c';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_EOF) {buf[i] = 'E';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_STICKY_EOF) {buf[i] = 'S';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_BLOCKED) {buf[i] = 'B';} else {buf [i]='_';}; i++; - if (flags & INPUT_SAW_CR) {buf[i] = '/';} else {buf [i]='_';}; i++; - if (flags & INPUT_NEED_NL) {buf[i] = '*';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_DEAD) {buf[i] = 'D';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_RAW_MODE) {buf[i] = 'R';} else {buf [i]='_';}; i++; + char buf[20]; + int i = 0; + + if (flags & TCL_READABLE) buf[i++] = 'r'; else buf[i++]='_'; + if (flags & TCL_WRITABLE) buf[i++] = 'w'; else buf[i++]='_'; + if (flags & CHANNEL_NONBLOCKING) buf[i++] = 'n'; else buf[i++]='_'; + if (flags & CHANNEL_LINEBUFFERED) buf[i++] = 'l'; else buf[i++]='_'; + if (flags & CHANNEL_UNBUFFERED) buf[i++] = 'u'; else buf[i++]='_'; + if (flags & BUFFER_READY) buf[i++] = 'R'; else buf[i++]='_'; + if (flags & BG_FLUSH_SCHEDULED) buf[i++] = 'F'; else buf[i++]='_'; + if (flags & CHANNEL_CLOSED) buf[i++] = 'c'; else buf[i++]='_'; + if (flags & CHANNEL_EOF) buf[i++] = 'E'; else buf[i++]='_'; + if (flags & CHANNEL_STICKY_EOF) buf[i++] = 'S'; else buf[i++]='_'; + if (flags & CHANNEL_BLOCKED) buf[i++] = 'B'; else buf[i++]='_'; + if (flags & INPUT_SAW_CR) buf[i++] = '/'; else buf[i++]='_'; + if (flags & INPUT_NEED_NL) buf[i++] = '*'; else buf[i++]='_'; + if (flags & CHANNEL_DEAD) buf[i++] = 'D'; else buf[i++]='_'; + if (flags & CHANNEL_RAW_MODE) buf[i++] = 'R'; else buf[i++]='_'; #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - if (flags & CHANNEL_TIMER_FEV) {buf[i] = 'T';} else {buf [i]='_';}; i++; - if (flags & CHANNEL_HAS_MORE_DATA) {buf[i] = 'H';} else {buf [i]='_';}; i++; + if (flags & CHANNEL_TIMER_FEV) buf[i++] = 'T'; else buf[i++]='_'; + if (flags & CHANNEL_HAS_MORE_DATA) buf[i++] = 'H'; else buf[i++]='_'; #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - if (flags & CHANNEL_INCLOSE) {buf[i] = 'x';} else {buf [i]='_';}; i++; - buf [i] ='\0'; + if (flags & CHANNEL_INCLOSE) buf[i++] = 'x'; else buf[i++]='_'; + buf[i] ='\0'; - fprintf (stderr,"%s: %s\n", str, buf); fflush(stderr); - return 0; + fprintf(stderr,"%s: %s\n", str, buf); + return 0; } #endif |