diff options
Diffstat (limited to 'generic/tclIO.c')
| -rw-r--r-- | generic/tclIO.c | 9723 |
1 files changed, 3917 insertions, 5806 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c index b06c14d..a1d5447 100644 --- a/generic/tclIO.c +++ b/generic/tclIO.c @@ -1,4 +1,4 @@ -/* +/* * tclIO.c -- * * This file provides the generic portions (those that are the same on @@ -7,38 +7,64 @@ * Copyright (c) 1998-2000 Ajuba Solutions * Copyright (c) 1995-1997 Sun Microsystems, Inc. * - * See the file "license.terms" for information on usage and redistribution of - * this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. */ #include "tclInt.h" +#include "tclPort.h" #include "tclIO.h" #include <assert.h> +#ifndef TCL_INHERIT_STD_CHANNELS +#define TCL_INHERIT_STD_CHANNELS 1 +#endif + + /* - * All static variables used in this file are collected into a single instance - * of the following structure. For multi-threaded implementations, there is - * one instance of this structure for each thread. + * All static variables used in this file are collected into a single + * instance of the following structure. For multi-threaded implementations, + * there is one instance of this structure for each thread. * - * Notice that different structures with the same name appear in other files. - * The structure defined below is used in this file only. + * Notice that different structures with the same name appear in other + * files. The structure defined below is used in this file only. */ typedef struct ThreadSpecificData { + + /* + * This variable holds the list of nested ChannelHandlerEventProc + * invocations. + */ NextChannelHandler *nestedHandlerPtr; - /* This variable holds the list of nested - * ChannelHandlerEventProc invocations. */ - ChannelState *firstCSPtr; /* List of all channels currently open, - * indexed by ChannelState, as only one - * ChannelState exists per set of stacked - * channels. */ - Tcl_Channel stdinChannel; /* Static variable for the stdin channel. */ + + /* + * List of all channels currently open, indexed by ChannelState, + * as only one ChannelState exists per set of stacked channels. + */ + ChannelState *firstCSPtr; +#ifdef oldcode + /* + * Has a channel exit handler been created yet? + */ + int channelExitHandlerCreated; + + /* + * Has the channel event source been created and registered with the + * notifier? + */ + int channelEventSourceCreated; +#endif + /* + * Static variables to hold channels for stdin, stdout and stderr. + */ + Tcl_Channel stdinChannel; int stdinInitialized; - Tcl_Channel stdoutChannel; /* Static variable for the stdout channel. */ + Tcl_Channel stdoutChannel; int stdoutInitialized; - Tcl_Channel stderrChannel; /* Static variable for the stderr channel. */ + Tcl_Channel stderrChannel; int stderrInitialized; - Tcl_Encoding binaryEncoding; + } ThreadSpecificData; static Tcl_ThreadDataKey dataKey; @@ -47,189 +73,88 @@ static Tcl_ThreadDataKey dataKey; * Static functions in this file: */ -static ChannelBuffer * AllocChannelBuffer(int length); -static void ChannelTimerProc(ClientData clientData); -static int CheckChannelErrors(ChannelState *statePtr, - int direction); -static int CheckFlush(Channel *chanPtr, ChannelBuffer *bufPtr, - int newlineFlag); -static int CheckForDeadChannel(Tcl_Interp *interp, - ChannelState *statePtr); -static void CheckForStdChannelsBeingClosed(Tcl_Channel chan); -static void CleanupChannelHandlers(Tcl_Interp *interp, - Channel *chanPtr); -static int CloseChannel(Tcl_Interp *interp, Channel *chanPtr, - int errorCode); -static int CloseChannelPart(Tcl_Interp *interp, Channel *chanPtr, - int errorCode, int flags); -static int CloseWrite(Tcl_Interp *interp, Channel *chanPtr); -static void CommonGetsCleanup(Channel *chanPtr); -static int CopyAndTranslateBuffer(ChannelState *statePtr, - char *result, int space); -static int CopyBuffer(Channel *chanPtr, char *result, int space); -static int CopyData(CopyState *csPtr, int mask); -static void CopyEventProc(ClientData clientData, int mask); -static void CreateScriptRecord(Tcl_Interp *interp, - Channel *chanPtr, int mask, Tcl_Obj *scriptPtr); -static void DeleteChannelTable(ClientData clientData, - Tcl_Interp *interp); -static void DeleteScriptRecord(Tcl_Interp *interp, - Channel *chanPtr, int mask); -static int DetachChannel(Tcl_Interp *interp, Tcl_Channel chan); -static void DiscardInputQueued(ChannelState *statePtr, - int discardSavedBuffers); -static void DiscardOutputQueued(ChannelState *chanPtr); -static int DoRead(Channel *chanPtr, char *srcPtr, int slen, int allowShortReads); -static int DoWrite(Channel *chanPtr, const char *src, int srcLen); -static int DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead, - int appendFlag); -static int DoWriteChars(Channel *chan, const char *src, int len); -static int FilterInputBytes(Channel *chanPtr, - GetsState *statePtr); -static int FlushChannel(Tcl_Interp *interp, Channel *chanPtr, - int calledFromAsyncFlush); -static int TclGetsObjBinary(Tcl_Channel chan, Tcl_Obj *objPtr); -static void FreeBinaryEncoding(ClientData clientData); -static Tcl_HashTable * GetChannelTable(Tcl_Interp *interp); -static int GetInput(Channel *chanPtr); -static int HaveVersion(const Tcl_ChannelType *typePtr, - Tcl_ChannelTypeVersion minimumVersion); -static void PeekAhead(Channel *chanPtr, char **dstEndPtr, - GetsState *gsPtr); -static int ReadBytes(ChannelState *statePtr, Tcl_Obj *objPtr, - int charsLeft, int *offsetPtr); -static int ReadChars(ChannelState *statePtr, Tcl_Obj *objPtr, - int charsLeft, int *offsetPtr, int *factorPtr); -static void RecycleBuffer(ChannelState *statePtr, - ChannelBuffer *bufPtr, int mustDiscard); -static int StackSetBlockMode(Channel *chanPtr, int mode); -static int SetBlockMode(Tcl_Interp *interp, Channel *chanPtr, - int mode); -static void StopCopy(CopyState *csPtr); -static int TranslateInputEOL(ChannelState *statePtr, char *dst, - const char *src, int *dstLenPtr, int *srcLenPtr); -static int TranslateOutputEOL(ChannelState *statePtr, char *dst, - const char *src, int *dstLenPtr, int *srcLenPtr); -static void UpdateInterest(Channel *chanPtr); -static int WriteBytes(Channel *chanPtr, const char *src, - int srcLen); -static int WriteChars(Channel *chanPtr, const char *src, - int srcLen); -static Tcl_Obj * FixLevelCode(Tcl_Obj *msg); -static void SpliceChannel(Tcl_Channel chan); -static void CutChannel(Tcl_Channel chan); -static int WillRead(Channel *chanPtr); - -/* - * Simplifying helper macros. All may use their argument(s) multiple times. - * The ANSI C "prototypes" for the macros are listed below, together with a - * short description of what the macro does. - * - * -------------------------------------------------------------------------- - * int BytesLeft(ChannelBuffer *bufPtr) - * - * Returns the number of bytes of data remaining in the buffer. - * - * int SpaceLeft(ChannelBuffer *bufPtr) - * - * Returns the number of bytes of space remaining at the end of the - * buffer. - * - * int IsBufferReady(ChannelBuffer *bufPtr) - * - * Returns whether a buffer has bytes available within it. - * - * int IsBufferEmpty(ChannelBuffer *bufPtr) - * - * Returns whether a buffer is entirely empty. Note that this is not the - * inverse of the above operation; trying to merge the two seems to lead - * to occasional crashes... - * - * int IsBufferFull(ChannelBuffer *bufPtr) - * - * Returns whether more data can be added to a buffer. - * - * int IsBufferOverflowing(ChannelBuffer *bufPtr) - * - * Returns whether a buffer has more data in it than it should. - * - * char *InsertPoint(ChannelBuffer *bufPtr) - * - * Returns a pointer to where characters should be added to the buffer. - * - * char *RemovePoint(ChannelBuffer *bufPtr) - * - * Returns a pointer to where characters should be removed from the - * buffer. - * -------------------------------------------------------------------------- - */ - -#define BytesLeft(bufPtr) ((bufPtr)->nextAdded - (bufPtr)->nextRemoved) - -#define SpaceLeft(bufPtr) ((bufPtr)->bufLength - (bufPtr)->nextAdded) - -#define IsBufferReady(bufPtr) ((bufPtr)->nextAdded > (bufPtr)->nextRemoved) - -#define IsBufferEmpty(bufPtr) ((bufPtr)->nextAdded == (bufPtr)->nextRemoved) - -#define IsBufferFull(bufPtr) ((bufPtr)->nextAdded >= (bufPtr)->bufLength) - -#define IsBufferOverflowing(bufPtr) ((bufPtr)->nextAdded>(bufPtr)->bufLength) - -#define InsertPoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextAdded) - -#define RemovePoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextRemoved) - -/* - * For working with channel state flag bits. - */ - -#define SetFlag(statePtr, flag) ((statePtr)->flags |= (flag)) -#define ResetFlag(statePtr, flag) ((statePtr)->flags &= ~(flag)) -#define GotFlag(statePtr, flag) ((statePtr)->flags & (flag)) - -/* - * Macro for testing whether a string (in optionName, length len) matches a - * value (prefix matching rules). Arguments are the minimum length to match - * and the value to match against. (Can't use Tcl_GetIndexFromObj as this is - * used in a situation where no objects are available.) - */ - -#define HaveOpt(minLength, nameString) \ - ((len > (minLength)) && (optionName[1] == (nameString)[1]) \ - && (strncmp(optionName, (nameString), len) == 0)) - -/* - * The ChannelObjType type. We actually store the ChannelState structure - * as that lives longest and we want to return the bottomChanPtr when - * requested (consistent with Tcl_GetChannel). The setFromAny and - * updateString can be NULL as they should not be called. - */ - -static void DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr); -static int SetChannelFromAny(Tcl_Interp *interp, - Tcl_Obj *objPtr); -static void UpdateStringOfChannel(Tcl_Obj *objPtr); -static void FreeChannelIntRep(Tcl_Obj *objPtr); - -static const Tcl_ObjType tclChannelType = { - "channel", /* name for this type */ - FreeChannelIntRep, /* freeIntRepProc */ - DupChannelIntRep, /* dupIntRepProc */ - NULL, /* updateStringProc UpdateStringOfChannel */ - NULL /* setFromAnyProc SetChannelFromAny */ -}; - -#define GET_CHANNELSTATE(objPtr) \ - ((ChannelState *) (objPtr)->internalRep.otherValuePtr) -#define SET_CHANNELSTATE(objPtr, storePtr) \ - ((objPtr)->internalRep.otherValuePtr = (void *) (storePtr)) -#define GET_CHANNELINTERP(objPtr) \ - ((Interp *) (objPtr)->internalRep.twoPtrValue.ptr2) -#define SET_CHANNELINTERP(objPtr, storePtr) \ - ((objPtr)->internalRep.twoPtrValue.ptr2 = (void *) (storePtr)) - -#define BUSY_STATE(st, fl) \ +static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length)); +static void ChannelTimerProc _ANSI_ARGS_(( + ClientData clientData)); +static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr, + int direction)); +static int CheckFlush _ANSI_ARGS_((Channel *chanPtr, + ChannelBuffer *bufPtr, int newlineFlag)); +static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp, + ChannelState *statePtr)); +static void CheckForStdChannelsBeingClosed _ANSI_ARGS_(( + Tcl_Channel chan)); +static void CleanupChannelHandlers _ANSI_ARGS_(( + Tcl_Interp *interp, Channel *chanPtr)); +static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp, + Channel *chanPtr, int errorCode)); +static void CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr, + 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)); +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)); +static void DeleteChannelTable _ANSI_ARGS_(( + 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)); +static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr, + int discardSavedBuffers)); +static void DiscardOutputQueued _ANSI_ARGS_(( + ChannelState *chanPtr)); +static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr, + 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)); +static int FilterInputBytes _ANSI_ARGS_((Channel *chanPtr, + GetsState *statePtr)); +static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp, + 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)); +static void PeekAhead _ANSI_ARGS_((Channel *chanPtr, + char **dstEndPtr, GetsState *gsPtr)); +static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr, + Tcl_Obj *objPtr, int charsLeft, + int *offsetPtr)); +static int ReadChars _ANSI_ARGS_((ChannelState *statePtr, + Tcl_Obj *objPtr, int charsLeft, + int *offsetPtr, int *factorPtr)); +static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr, + ChannelBuffer *bufPtr, int mustDiscard)); +static int StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr, + int mode)); +static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp, + Channel *chanPtr, int mode)); +static void StopCopy _ANSI_ARGS_((CopyState *csPtr)); +static int TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr, + char *dst, CONST char *src, + int *dstLenPtr, int *srcLenPtr)); +static int TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr, + char *dst, CONST char *src, + int *dstLenPtr, int *srcLenPtr)); +static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr)); +static int WriteBytes _ANSI_ARGS_((Channel *chanPtr, + CONST char *src, int srcLen)); +static int WriteChars _ANSI_ARGS_((Channel *chanPtr, + CONST char *src, int srcLen)); + +#define BUSY_STATE(st,fl) \ ((((st)->csPtrR) && ((fl) & TCL_READABLE)) || \ (((st)->csPtrW) && ((fl) & TCL_WRITABLE))) @@ -238,117 +163,10 @@ static const Tcl_ObjType tclChannelType = { /* *--------------------------------------------------------------------------- * - * ChanClose, ChanRead, ChanSeek, ChanThreadAction, ChanWatch, ChanWrite -- - * - * Simplify the access to selected channel driver "methods" that are used - * in multiple places in a stereotypical fashion. These are just thin - * wrappers around the driver functions. - * - *--------------------------------------------------------------------------- - */ - -static inline int -ChanClose( - Channel *chanPtr, - Tcl_Interp *interp) -{ - if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { - return chanPtr->typePtr->closeProc(chanPtr->instanceData, interp); - } else { - return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, 0); - } -} - -static inline int -ChanCloseHalf( - Channel *chanPtr, - Tcl_Interp *interp, - int flags) -{ - return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, flags); -} - -static inline int -ChanRead( - Channel *chanPtr, - char *dst, - int dstSize, - int *errnoPtr) -{ - if (WillRead(chanPtr) < 0) { - return -1; - } - - return chanPtr->typePtr->inputProc(chanPtr->instanceData, dst, dstSize, - errnoPtr); -} - -static inline Tcl_WideInt -ChanSeek( - Channel *chanPtr, - Tcl_WideInt offset, - int mode, - int *errnoPtr) -{ - /* - * Note that we prefer the wideSeekProc if that field is available in the - * type and non-NULL. - */ - - if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && - chanPtr->typePtr->wideSeekProc != NULL) { - return chanPtr->typePtr->wideSeekProc(chanPtr->instanceData, - offset, mode, errnoPtr); - } - - if (offset<Tcl_LongAsWide(LONG_MIN) || offset>Tcl_LongAsWide(LONG_MAX)) { - *errnoPtr = EOVERFLOW; - return Tcl_LongAsWide(-1); - } - - return Tcl_LongAsWide(chanPtr->typePtr->seekProc(chanPtr->instanceData, - Tcl_WideAsLong(offset), mode, errnoPtr)); -} - -static inline void -ChanThreadAction( - Channel *chanPtr, - int action) -{ - Tcl_DriverThreadActionProc *threadActionProc = - Tcl_ChannelThreadActionProc(chanPtr->typePtr); - - if (threadActionProc != NULL) { - threadActionProc(chanPtr->instanceData, action); - } -} - -static inline void -ChanWatch( - Channel *chanPtr, - int mask) -{ - chanPtr->typePtr->watchProc(chanPtr->instanceData, mask); -} - -static inline int -ChanWrite( - Channel *chanPtr, - const char *src, - int srcLen, - int *errnoPtr) -{ - return chanPtr->typePtr->outputProc(chanPtr->instanceData, src, srcLen, - errnoPtr); -} - -/* - *--------------------------------------------------------------------------- - * * TclInitIOSubsystem -- * * Initialize all resources used by this subsystem on a per-process - * basis. + * basis. * * Results: * None. @@ -360,24 +178,23 @@ ChanWrite( */ void -TclInitIOSubsystem(void) +TclInitIOSubsystem() { /* - * By fetching thread local storage we take care of allocating it for each - * thread. + * By fetching thread local storage we take care of + * allocating it for each thread. */ - (void) TCL_TSD_INIT(&dataKey); -} +} /* *------------------------------------------------------------------------- * * TclFinalizeIOSubsystem -- * - * Releases all resources used by this subsystem on a per-process basis. - * Closes all extant channels that have not already been closed because - * they were not owned by any interp. + * Releases all resources used by this subsystem on a per-thread + * basis. Closes all extant channels that have not already been + * closed because they were not owned by any interp. * * Results: * None. @@ -396,108 +213,94 @@ TclFinalizeIOSubsystem(void) Channel *chanPtr = NULL; /* Iterates over open channels. */ ChannelState *statePtr; /* State of channel stack */ int active = 1; /* Flag == 1 while there's still work to do */ - int doflushnb; - - /* Fetch the pre-TIP#398 compatibility flag */ - { - const char *s; - Tcl_DString ds; - - s = TclGetEnv("TCL_FLUSH_NONBLOCKING_ON_EXIT", &ds); - doflushnb = ((s != NULL) && strcmp(s, "0")); - if (s != NULL) { - Tcl_DStringFree(&ds); - } - } /* - * Walk all channel state structures known to this thread and close - * corresponding channels. + * Walk all channel state structures known to this thread and + * close corresponding channels. */ while (active) { + /* - * Iterate through the open channel list, and find the first channel - * that isn't dead. We start from the head of the list each time, - * because the close action on one channel can close others. + * Iterate through the open channel list, and find the first + * channel that isn't dead. We start from the head of the list + * each time, because the close action on one channel can close + * others. */ active = 0; for (statePtr = tsdPtr->firstCSPtr; - statePtr != NULL; - statePtr = statePtr->nextCSPtr) { + statePtr != NULL; + statePtr = statePtr->nextCSPtr) { chanPtr = statePtr->topChanPtr; - if (!GotFlag(statePtr, CHANNEL_INCLOSE | CHANNEL_CLOSED | CHANNEL_DEAD) - || (doflushnb && GotFlag(statePtr, BG_FLUSH_SCHEDULED))) { + if (!(statePtr->flags & (CHANNEL_INCLOSE|CHANNEL_CLOSED|CHANNEL_DEAD))) { active = 1; break; } } /* - * We've found a live channel. Close it. + * We've found a live channel. Close it. */ if (active) { /* - * TIP #398: by default, we no longer set the channel back into - * blocking mode. To restore the old blocking behavior, the - * environment variable TCL_FLUSH_NONBLOCKING_ON_EXIT must be set - * and not be "0". + * Set the channel back into blocking mode to ensure that we + * wait for all data to flush out. */ - if (doflushnb) { - /* Set the channel back into blocking mode to ensure that we wait - * for all data to flush out. - */ - - (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, - "-blocking", "on"); - } - + + (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, + "-blocking", "on"); + if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || - (chanPtr == (Channel *) tsdPtr->stdoutChannel) || - (chanPtr == (Channel *) tsdPtr->stderrChannel)) { + (chanPtr == (Channel *) tsdPtr->stdoutChannel) || + (chanPtr == (Channel *) tsdPtr->stderrChannel)) { /* - * Decrement the refcount which was earlier artificially + * Decrement the refcount which was earlier artificially * bumped up to keep the channel from being closed. */ - + statePtr->refCount--; } - + if (statePtr->refCount <= 0) { /* - * Close it only if the refcount indicates that the channel is - * not referenced from any interpreter. If it is, that + * Close it only if the refcount indicates that the channel + * is not referenced from any interpreter. If it is, that * interpreter will close the channel when it gets destroyed. */ - + (void) Tcl_Close(NULL, (Tcl_Channel) chanPtr); } else { /* * The refcount is greater than zero, so flush the channel. */ - - ResetFlag(statePtr, BG_FLUSH_SCHEDULED); + Tcl_Flush((Tcl_Channel) chanPtr); - + /* - * Call the device driver to actually close the underlying + * Call the device driver to actually close the underlying * device for this channel. */ - - (void) ChanClose(chanPtr, NULL); - + + if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { + (chanPtr->typePtr->closeProc)(chanPtr->instanceData, NULL); + } else { + (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, + 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 = NULL; - SetFlag(statePtr, CHANNEL_DEAD); + statePtr->flags |= CHANNEL_DEAD; } } } @@ -505,14 +308,15 @@ TclFinalizeIOSubsystem(void) TclpFinalizeSockets(); TclpFinalizePipes(); } + /* *---------------------------------------------------------------------- * * Tcl_SetStdChannel -- * - * This function is used to change the channels that are used for - * stdin/stdout/stderr in new interpreters. + * This function is used to change the channels that are used + * for stdin/stdout/stderr in new interpreters. * * Results: * None @@ -524,25 +328,24 @@ TclFinalizeIOSubsystem(void) */ void -Tcl_SetStdChannel( - Tcl_Channel channel, - int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ +Tcl_SetStdChannel(channel, type) + Tcl_Channel channel; + int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - switch (type) { - case TCL_STDIN: - tsdPtr->stdinInitialized = 1; - tsdPtr->stdinChannel = channel; - break; - case TCL_STDOUT: - tsdPtr->stdoutInitialized = 1; - tsdPtr->stdoutChannel = channel; - break; - case TCL_STDERR: - tsdPtr->stderrInitialized = 1; - tsdPtr->stderrChannel = channel; - break; + case TCL_STDIN: + tsdPtr->stdinInitialized = 1; + tsdPtr->stdinChannel = channel; + break; + case TCL_STDOUT: + tsdPtr->stdoutInitialized = 1; + tsdPtr->stdoutChannel = channel; + break; + case TCL_STDERR: + tsdPtr->stderrInitialized = 1; + tsdPtr->stderrChannel = channel; + break; } } @@ -557,67 +360,71 @@ Tcl_SetStdChannel( * Returns the specified standard channel, or NULL. * * Side effects: - * May cause the creation of a standard channel and the underlying file. + * May cause the creation of a standard channel and the underlying + * file. * *---------------------------------------------------------------------- */ - Tcl_Channel -Tcl_GetStdChannel( - int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ +Tcl_GetStdChannel(type) + int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ { Tcl_Channel channel = NULL; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); /* - * If the channels were not created yet, create them now and store them in - * the static variables. + * If the channels were not created yet, create them now and + * store them in the static variables. */ switch (type) { - case TCL_STDIN: - if (!tsdPtr->stdinInitialized) { - tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN); - tsdPtr->stdinInitialized = 1; - - /* - * Artificially bump the refcount to ensure that the channel is - * only closed on exit. - * - * NOTE: Must only do this if stdinChannel is not NULL. It can be - * NULL in situations where Tcl is unable to connect to the - * standard input. - */ + case TCL_STDIN: + if (!tsdPtr->stdinInitialized) { + tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN); + tsdPtr->stdinInitialized = 1; - if (tsdPtr->stdinChannel != NULL) { - Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel); - } - } - channel = tsdPtr->stdinChannel; - break; - case TCL_STDOUT: - if (!tsdPtr->stdoutInitialized) { - tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT); - tsdPtr->stdoutInitialized = 1; - if (tsdPtr->stdoutChannel != NULL) { - Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel); - } - } - channel = tsdPtr->stdoutChannel; - break; - case TCL_STDERR: - if (!tsdPtr->stderrInitialized) { - tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR); - tsdPtr->stderrInitialized = 1; - if (tsdPtr->stderrChannel != NULL) { - Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel); - } - } - channel = tsdPtr->stderrChannel; - break; + /* + * 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; + case TCL_STDOUT: + 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); + } + } + channel = tsdPtr->stdoutChannel; + break; + case TCL_STDERR: + 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); + } + } + channel = tsdPtr->stderrChannel; + break; } return channel; } + /* *---------------------------------------------------------------------- @@ -631,25 +438,27 @@ Tcl_GetStdChannel( * None. * * Side effects: - * Causes the callback to be called in the future when the channel will - * be closed. + * Causes the callback to be called in the future when the channel + * will be closed. * *---------------------------------------------------------------------- */ void -Tcl_CreateCloseHandler( - Tcl_Channel chan, /* The channel for which to create the close - * callback. */ - Tcl_CloseProc *proc, /* The callback routine to call when the - * channel will be closed. */ - ClientData clientData) /* Arbitrary data to pass to the close - * callback. */ +Tcl_CreateCloseHandler(chan, proc, clientData) + Tcl_Channel chan; /* The channel for which to create the + * close callback. */ + Tcl_CloseProc *proc; /* The callback routine to call when the + * channel will be closed. */ + ClientData clientData; /* Arbitrary data to pass to the + * close callback. */ { - ChannelState *statePtr = ((Channel *) chan)->state; + ChannelState *statePtr; CloseCallback *cbPtr; - cbPtr = ckalloc(sizeof(CloseCallback)); + statePtr = ((Channel *) chan)->state; + + cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback)); cbPtr->proc = proc; cbPtr->clientData = clientData; @@ -662,41 +471,45 @@ Tcl_CreateCloseHandler( * * Tcl_DeleteCloseHandler -- * - * Removes a callback that would have been called on closing the channel. - * If there is no matching callback then this function has no effect. + * Removes a callback that would have been called on closing + * the channel. If there is no matching callback then this + * function has no effect. * * Results: * None. * * Side effects: - * The callback will not be called in the future when the channel is - * eventually closed. + * The callback will not be called in the future when the channel + * is eventually closed. * *---------------------------------------------------------------------- */ void -Tcl_DeleteCloseHandler( - Tcl_Channel chan, /* The channel for which to cancel the close - * callback. */ - Tcl_CloseProc *proc, /* The procedure for the callback to - * remove. */ - ClientData clientData) /* The callback data for the callback to - * remove. */ +Tcl_DeleteCloseHandler(chan, proc, clientData) + Tcl_Channel chan; /* The channel for which to cancel the + * close callback. */ + Tcl_CloseProc *proc; /* The procedure for the callback to + * remove. */ + ClientData clientData; /* The callback data for the callback + * to remove. */ { - ChannelState *statePtr = ((Channel *) chan)->state; + ChannelState *statePtr; CloseCallback *cbPtr, *cbPrevPtr; - for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = NULL; - cbPtr != NULL; cbPtr = cbPtr->nextPtr) { - if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) { - if (cbPrevPtr == NULL) { - statePtr->closeCbPtr = cbPtr->nextPtr; - } - ckfree(cbPtr); - break; - } - cbPrevPtr = cbPtr; + 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; + } } } @@ -705,53 +518,58 @@ Tcl_DeleteCloseHandler( * * GetChannelTable -- * - * Gets and potentially initializes the channel table for an interpreter. - * If it is initializing the table it also inserts channels for stdin, - * stdout and stderr if the interpreter is trusted. + * Gets and potentially initializes the channel table for an + * interpreter. If it is initializing the table it also inserts + * channels for stdin, stdout and stderr if the interpreter is + * trusted. * * Results: * A pointer to the hash table created, for use by the caller. * * Side effects: - * Initializes the channel table for an interpreter. May create channels - * for stdin, stdout and stderr. + * Initializes the channel table for an interpreter. May create + * channels for stdin, stdout and stderr. * *---------------------------------------------------------------------- */ static Tcl_HashTable * -GetChannelTable( - Tcl_Interp *interp) +GetChannelTable(interp) + Tcl_Interp *interp; { Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_Channel stdinChan, stdoutChan, stderrChan; - hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); - if (hTblPtr == NULL) { - hTblPtr = ckalloc(sizeof(Tcl_HashTable)); - Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS); - Tcl_SetAssocData(interp, "tclIO", - (Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr); + 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); - /* - * If the interpreter is trusted (not "safe"), insert channels for - * stdin, stdout and stderr (possibly creating them in the process). - */ + (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); + } + } - 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; } @@ -762,8 +580,9 @@ GetChannelTable( * DeleteChannelTable -- * * Deletes the channel table for an interpreter, closing any open - * channels whose refcount reaches zero. This procedure is invoked when - * an interpreter is deleted, via the AssocData cleanup mechanism. + * channels whose refcount reaches zero. This procedure is invoked + * when an interpreter is deleted, via the AssocData cleanup + * mechanism. * * Results: * None. @@ -777,9 +596,9 @@ GetChannelTable( */ static void -DeleteChannelTable( - ClientData clientData, /* The per-interpreter data structure. */ - Tcl_Interp *interp) /* The interpreter being deleted. */ +DeleteChannelTable(clientData, interp) + ClientData clientData; /* The per-interpreter data structure. */ + Tcl_Interp *interp; /* The interpreter being deleted. */ { Tcl_HashTable *hTblPtr; /* The hash table. */ Tcl_HashSearch hSearch; /* Search variable. */ @@ -787,64 +606,66 @@ DeleteChannelTable( Channel *chanPtr; /* Channel being deleted. */ ChannelState *statePtr; /* State of Channel being deleted. */ EventScriptRecord *sPtr, *prevPtr, *nextPtr; - /* Variables to loop over all channel events - * registered, to delete the ones that refer - * to the interpreter being deleted. */ + /* Variables to loop over all channel events + * registered, to delete the ones that refer + * to the interpreter being deleted. */ /* * Delete all the registered channels - this will close channels whose * refcount reaches zero. */ + + hTblPtr = (Tcl_HashTable *) clientData; + for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); + hPtr != (Tcl_HashEntry *) NULL; + hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) { - hTblPtr = clientData; - for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL; - hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) { - chanPtr = Tcl_GetHashValue(hPtr); + chanPtr = (Channel *) Tcl_GetHashValue(hPtr); statePtr = chanPtr->state; - /* - * Remove any fileevents registered in this interpreter. - */ - - for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL; - sPtr != NULL; sPtr = nextPtr) { - nextPtr = sPtr->nextPtr; - if (sPtr->interp == interp) { - if (prevPtr == NULL) { - statePtr->scriptRecordPtr = nextPtr; - } else { - prevPtr->nextPtr = nextPtr; - } - - Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, - TclChannelEventScriptInvoker, sPtr); - - TclDecrRefCount(sPtr->scriptPtr); - ckfree(sPtr); - } else { - prevPtr = sPtr; - } - } - - /* - * Cannot call Tcl_UnregisterChannel because that procedure calls - * Tcl_GetAssocData to get the channel table, which might already be - * inaccessible from the interpreter structure. Instead, we emulate - * the behavior of Tcl_UnregisterChannel directly here. - */ + /* + * 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; + } + } - Tcl_DeleteHashEntry(hPtr); - SetFlag(statePtr, CHANNEL_TAINTED); - statePtr->refCount--; - if (statePtr->refCount <= 0) { - if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - (void) Tcl_Close(interp, (Tcl_Channel) chanPtr); - } - } + /* + * 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(hTblPtr); + ckfree((char *) hTblPtr); } /* @@ -853,11 +674,11 @@ DeleteChannelTable( * CheckForStdChannelsBeingClosed -- * * Perform special handling for standard channels being closed. When - * given a standard channel, if the refcount is now 1, it means that the - * last reference to the standard channel is being explicitly closed. Now - * bump the refcount artificially down to 0, to ensure the normal - * handling of channels being closed will occur. Also reset the static - * pointer to the channel to NULL, to avoid dangling references. + * given a standard channel, if the refcount is now 1, it means that + * the last reference to the standard channel is being explicitly + * closed. Now bump the refcount artificially down to 0, to ensure the + * normal handling of channels being closed will occur. Also reset the + * static pointer to the channel to NULL, to avoid dangling references. * * Results: * None. @@ -870,30 +691,32 @@ DeleteChannelTable( */ static void -CheckForStdChannelsBeingClosed( - Tcl_Channel chan) +CheckForStdChannelsBeingClosed(chan) + Tcl_Channel chan; { ChannelState *statePtr = ((Channel *) chan)->state; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - if ((chan == tsdPtr->stdinChannel) && tsdPtr->stdinInitialized) { - 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; - } - } else if ((chan == tsdPtr->stderrChannel) && tsdPtr->stderrInitialized) { - if (statePtr->refCount < 2) { - statePtr->refCount = 0; - tsdPtr->stderrChannel = NULL; - return; - } + if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) { + 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; + } + } else if ((chan == tsdPtr->stderrChannel) + && (tsdPtr->stderrInitialized)) { + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stderrChannel = NULL; + return; + } } } @@ -902,28 +725,27 @@ CheckForStdChannelsBeingClosed( * * Tcl_IsStandardChannel -- * - * Test if the given channel is a standard channel. No attempt is made to - * check if the channel or the standard channels are initialized or - * otherwise valid. + * Test if the given channel is a standard channel. No attempt + * is made to check if the channel or the standard channels + * are initialized or otherwise valid. * * Results: * Returns 1 if true, 0 if false. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ - -int -Tcl_IsStandardChannel( - Tcl_Channel chan) /* Channel to check. */ +int +Tcl_IsStandardChannel(chan) + Tcl_Channel chan; /* Channel to check. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - if ((chan == tsdPtr->stdinChannel) - || (chan == tsdPtr->stdoutChannel) - || (chan == tsdPtr->stderrChannel)) { + if ((chan == tsdPtr->stdinChannel) + || (chan == tsdPtr->stdoutChannel) + || (chan == tsdPtr->stderrChannel)) { return 1; } else { return 0; @@ -936,8 +758,8 @@ Tcl_IsStandardChannel( * Tcl_RegisterChannel -- * * Adds an already-open channel to the channel table of an interpreter. - * If the interpreter passed as argument is NULL, it only increments the - * channel refCount. + * If the interpreter passed as argument is NULL, it only increments + * the channel refCount. * * Results: * None. @@ -949,41 +771,41 @@ Tcl_IsStandardChannel( */ void -Tcl_RegisterChannel( - Tcl_Interp *interp, /* Interpreter in which to add the channel. */ - Tcl_Channel chan) /* The channel to add to this interpreter - * channel table. */ +Tcl_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. */ { Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_HashEntry *hPtr; /* Search variable. */ - int isNew; /* Is the hash entry new or does it exist? */ + int new; /* Is the hash entry new or does it exist? */ Channel *chanPtr; /* The actual channel. */ ChannelState *statePtr; /* State of the actual channel. */ /* - * Always (un)register bottom-most channel in the stack. This makes + * Always (un)register bottom-most channel in the stack. This makes * management of the channel list easier because no manipulation is * necessary during (un)stack operation. */ - chanPtr = ((Channel *) chan)->state->bottomChanPtr; statePtr = chanPtr->state; - if (statePtr->channelName == NULL) { - Tcl_Panic("Tcl_RegisterChannel: channel without name"); + if (statePtr->channelName == (CONST char *) NULL) { + panic("Tcl_RegisterChannel: channel without name"); } - if (interp != NULL) { - hTblPtr = GetChannelTable(interp); - hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &isNew); - if (!isNew) { - if (chan == Tcl_GetHashValue(hPtr)) { - return; - } + 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; + } - Tcl_Panic("Tcl_RegisterChannel: duplicate channel names"); - } - Tcl_SetHashValue(hPtr, chanPtr); + panic("Tcl_RegisterChannel: duplicate channel names"); + } + Tcl_SetHashValue(hPtr, (ClientData) chanPtr); } + statePtr->refCount++; } @@ -994,19 +816,19 @@ Tcl_RegisterChannel( * * Deletes the hash entry for a channel associated with an interpreter. * If the interpreter given as argument is NULL, it only decrements the - * reference count. (This all happens in the Tcl_DetachChannel helper + * reference count. (This all happens in the Tcl_DetachChannel helper * function). - * - * Finally, if the reference count of the channel drops to zero, it is - * deleted. + * + * Finally, if the reference count of the channel drops to zero, + * it is deleted. * * Results: * A standard Tcl result. * * Side effects: - * Calls Tcl_DetachChannel which deletes the hash entry for a channel + * Calls Tcl_DetachChannel which deletes the hash entry for a channel * associated with an interpreter. - * + * * May delete the channel, which can have a variety of consequences, * especially if we are forced to close the channel. * @@ -1014,26 +836,27 @@ Tcl_RegisterChannel( */ int -Tcl_UnregisterChannel( - Tcl_Interp *interp, /* Interpreter in which channel is defined. */ - Tcl_Channel chan) /* Channel to delete. */ +Tcl_UnregisterChannel(interp, chan) + Tcl_Interp *interp; /* Interpreter in which channel is defined. */ + Tcl_Channel chan; /* Channel to delete. */ { ChannelState *statePtr; /* State of the real channel. */ statePtr = ((Channel *) chan)->state->bottomChanPtr->state; - - if (GotFlag(statePtr, CHANNEL_INCLOSE)) { - if (interp != NULL) { - Tcl_AppendResult(interp, "Illegal recursive call to close " - "through close-handler of channel", NULL); + + 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); } - return TCL_ERROR; + return TCL_ERROR; } - + if (DetachChannel(interp, chan) != TCL_OK) { - return TCL_OK; + return TCL_OK; } - + statePtr = ((Channel *) chan)->state->bottomChanPtr->state; /* @@ -1051,31 +874,30 @@ Tcl_UnregisterChannel( */ if (statePtr->refCount <= 0) { - /* - * Ensure that if there is another buffer, it gets flushed whether or - * not we are doing a background flush. - */ - if ((statePtr->curOutPtr != NULL) && - IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); - } - Tcl_Preserve(statePtr); - if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - /* - * We don't want to re-enter Tcl_Close(). - */ + /* + * Ensure that if there is another buffer, it gets flushed + * whether or not we are doing a background flush. + */ - if (!GotFlag(statePtr, CHANNEL_CLOSED)) { + if ((statePtr->curOutPtr != NULL) && + (statePtr->curOutPtr->nextAdded > + statePtr->curOutPtr->nextRemoved)) { + statePtr->flags |= BUFFER_READY; + } + Tcl_Preserve((ClientData)statePtr); + 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) { - SetFlag(statePtr, CHANNEL_CLOSED); - Tcl_Release(statePtr); + statePtr->flags |= CHANNEL_CLOSED; + Tcl_Release((ClientData)statePtr); return TCL_ERROR; } } - } - SetFlag(statePtr, CHANNEL_CLOSED); - Tcl_Release(statePtr); + } + statePtr->flags |= CHANNEL_CLOSED; + Tcl_Release((ClientData)statePtr); } return TCL_OK; } @@ -1087,42 +909,45 @@ Tcl_UnregisterChannel( * * Deletes the hash entry for a channel associated with an interpreter. * If the interpreter given as argument is NULL, it only decrements the - * reference count. Even if the ref count drops to zero, the channel is - * NOT closed or cleaned up. This allows a channel to be detached from an - * interpreter and left in the same state it was in when it was - * originally returned by 'Tcl_OpenFileChannel', for example. - * - * This function cannot be used on the standard channels, and will return - * TCL_ERROR if that is attempted. - * - * This function should only be necessary for special purposes in which - * you need to generate a pristine channel from one that has already been - * used. All ordinary purposes will almost always want to use - * Tcl_UnregisterChannel instead. - * - * Provided the channel is not attached to any other interpreter, it can - * then be closed with Tcl_Close, rather than with Tcl_UnregisterChannel. + * reference count. Even if the ref count drops to zero, the + * channel is NOT closed or cleaned up. This allows a channel to + * be detached from an interpreter and left in the same state it + * was in when it was originally returned by 'Tcl_OpenFileChannel', + * for example. + * + * This function cannot be used on the standard channels, and + * will return TCL_ERROR if that is attempted. + * + * This function should only be necessary for special purposes + * in which you need to generate a pristine channel from one + * that has already been used. All ordinary purposes will almost + * always want to use Tcl_UnregisterChannel instead. + * + * Provided the channel is not attached to any other interpreter, + * it can then be closed with Tcl_Close, rather than with + * Tcl_UnregisterChannel. * * Results: - * A standard Tcl result. If the channel is not currently registered with - * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK. - * However no error messages are left in the interp's result. + * A standard Tcl result. If the channel is not currently registered + * with the given interpreter, TCL_ERROR is returned, otherwise + * TCL_OK. However no error messages are left in the interp's result. * * Side effects: - * Deletes the hash entry for a channel associated with an interpreter. + * Deletes the hash entry for a channel associated with an + * interpreter. * *---------------------------------------------------------------------- */ int -Tcl_DetachChannel( - Tcl_Interp *interp, /* Interpreter in which channel is defined. */ - Tcl_Channel chan) /* Channel to delete. */ +Tcl_DetachChannel(interp, chan) + Tcl_Interp *interp; /* Interpreter in which channel is defined. */ + Tcl_Channel chan; /* Channel to delete. */ { if (Tcl_IsStandardChannel(chan)) { - return TCL_ERROR; + return TCL_ERROR; } - + return DetachChannel(interp, chan); } @@ -1133,26 +958,28 @@ Tcl_DetachChannel( * * Deletes the hash entry for a channel associated with an interpreter. * If the interpreter given as argument is NULL, it only decrements the - * reference count. Even if the ref count drops to zero, the channel is - * NOT closed or cleaned up. This allows a channel to be detached from an - * interpreter and left in the same state it was in when it was - * originally returned by 'Tcl_OpenFileChannel', for example. + * reference count. Even if the ref count drops to zero, the + * channel is NOT closed or cleaned up. This allows a channel to + * be detached from an interpreter and left in the same state it + * was in when it was originally returned by 'Tcl_OpenFileChannel', + * for example. * * Results: - * A standard Tcl result. If the channel is not currently registered with - * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK. - * However no error messages are left in the interp's result. + * A standard Tcl result. If the channel is not currently registered + * with the given interpreter, TCL_ERROR is returned, otherwise + * TCL_OK. However no error messages are left in the interp's result. * * Side effects: - * Deletes the hash entry for a channel associated with an interpreter. + * Deletes the hash entry for a channel associated with an + * interpreter. * *---------------------------------------------------------------------- */ static int -DetachChannel( - Tcl_Interp *interp, /* Interpreter in which channel is defined. */ - Tcl_Channel chan) /* Channel to delete. */ +DetachChannel(interp, chan) + Tcl_Interp *interp; /* Interpreter in which channel is defined. */ + Tcl_Channel chan; /* Channel to delete. */ { Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_HashEntry *hPtr; /* Search variable. */ @@ -1160,44 +987,43 @@ DetachChannel( ChannelState *statePtr; /* State of the real channel. */ /* - * Always (un)register bottom-most channel in the stack. This makes + * Always (un)register bottom-most channel in the stack. This makes * management of the channel list easier because no manipulation is * necessary during (un)stack operation. */ - chanPtr = ((Channel *) chan)->state->bottomChanPtr; statePtr = chanPtr->state; - if (interp != NULL) { - hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); - if (hTblPtr == NULL) { + if (interp != (Tcl_Interp *) NULL) { + hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL); + if (hTblPtr == (Tcl_HashTable *) NULL) { return TCL_ERROR; } hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName); - if (hPtr == NULL) { + if (hPtr == (Tcl_HashEntry *) NULL) { return TCL_ERROR; } if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { return TCL_ERROR; } Tcl_DeleteHashEntry(hPtr); - SetFlag(statePtr, CHANNEL_TAINTED); /* - * Remove channel handlers that refer to this interpreter, so that - * they will not be present if the actual close is delayed and more - * events happen on the channel. This may occur if the channel is - * shared between several interpreters, or if the channel has async + * Remove channel handlers that refer to this interpreter, so that they + * will not be present if the actual close is delayed and more events + * happen on the channel. This may occur if the channel is shared + * between several interpreters, or if the channel has async * flushing active. */ - + CleanupChannelHandlers(interp, chanPtr); } statePtr->refCount--; - + return TCL_OK; } + /* *--------------------------------------------------------------------------- @@ -1209,9 +1035,9 @@ DetachChannel( * channel-type-specific functions. * * Results: - * A Tcl_Channel or NULL on failure. If failed, interp's result object - * contains an error message. *modePtr is filled with the modes in which - * the channel was opened. + * A Tcl_Channel or NULL on failure. If failed, interp's result + * object contains an error message. *modePtr is filled with the + * modes in which the channel was opened. * * Side effects: * None. @@ -1220,26 +1046,26 @@ DetachChannel( */ Tcl_Channel -Tcl_GetChannel( - Tcl_Interp *interp, /* Interpreter in which to find or create the - * channel. */ - const char *chanName, /* The name of the channel. */ - int *modePtr) /* Where to store the mode in which the - * channel was opened? Will contain an ORed - * combination of TCL_READABLE and - * TCL_WRITABLE, if non-NULL. */ +Tcl_GetChannel(interp, chanName, modePtr) + Tcl_Interp *interp; /* Interpreter in which to find or create + * the channel. */ + CONST char *chanName; /* The name of the channel. */ + int *modePtr; /* Where to store the mode in which the + * channel was opened? Will contain an ORed + * combination of TCL_READABLE and + * TCL_WRITABLE, if non-NULL. */ { Channel *chanPtr; /* The actual channel. */ Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_HashEntry *hPtr; /* Search variable. */ - const char *name; /* Translated name. */ + CONST char *name; /* Translated name. */ /* - * Substitute "stdin", etc. Note that even though we immediately find the - * channel using Tcl_GetStdChannel, we still need to look it up in the - * specified interpreter to ensure that it is present in the channel - * table. Otherwise, safe interpreters would always have access to the - * standard channels. + * Substitute "stdin", etc. Note that even though we immediately + * find the channel using Tcl_GetStdChannel, we still need to look + * it up in the specified interpreter to ensure that it is present + * in the channel table. Otherwise, safe interpreters would always + * have access to the standard channels. */ name = chanName; @@ -1259,105 +1085,57 @@ Tcl_GetChannel( hTblPtr = GetChannelTable(interp); hPtr = Tcl_FindHashEntry(hTblPtr, name); - if (hPtr == NULL) { - Tcl_AppendResult(interp, "can not find channel named \"", chanName, - "\"", NULL); - Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CHANNEL", chanName, NULL); - return NULL; + if (hPtr == (Tcl_HashEntry *) NULL) { + Tcl_AppendResult(interp, "can not find channel named \"", + chanName, "\"", (char *) NULL); + return NULL; } /* - * Always return bottom-most channel in the stack. This one lives the - * longest - other channels may go away unnoticed. The other APIs - * compensate where necessary to retrieve the topmost channel again. + * Always return bottom-most channel in the stack. This one lives + * the longest - other channels may go away unnoticed. + * The other APIs compensate where necessary to retrieve the + * topmost channel again. */ - - chanPtr = Tcl_GetHashValue(hPtr); + chanPtr = (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; } /* - *--------------------------------------------------------------------------- - * - * TclGetChannelFromObj -- - * - * Finds an existing Tcl_Channel structure by name in a given - * interpreter. This function is public because it is used by - * channel-type-specific functions. - * - * Results: - * A Tcl_Channel or NULL on failure. If failed, interp's result object - * contains an error message. *modePtr is filled with the modes in which - * the channel was opened. - * - * Side effects: - * None. - * - *--------------------------------------------------------------------------- - */ - -int -TclGetChannelFromObj( - Tcl_Interp *interp, /* Interpreter in which to find or create the - * channel. */ - Tcl_Obj *objPtr, - Tcl_Channel *channelPtr, - int *modePtr, /* Where to store the mode in which the - * channel was opened? Will contain an ORed - * combination of TCL_READABLE and - * TCL_WRITABLE, if non-NULL. */ - int flags) -{ - ChannelState *statePtr; - - if (SetChannelFromAny(interp, objPtr) != TCL_OK) { - return TCL_ERROR; - } - - statePtr = GET_CHANNELSTATE(objPtr); - *channelPtr = (Tcl_Channel) statePtr->bottomChanPtr; - - if (modePtr != NULL) { - *modePtr = statePtr->flags & (TCL_READABLE|TCL_WRITABLE); - } - - return TCL_OK; -} - -/* *---------------------------------------------------------------------- * * Tcl_CreateChannel -- * - * Creates a new entry in the hash table for a Tcl_Channel record. + * Creates a new entry in the hash table for a Tcl_Channel + * record. * * Results: * Returns the new Tcl_Channel. * * Side effects: - * Creates a new Tcl_Channel instance and inserts it into the hash table. + * Creates a new Tcl_Channel instance and inserts it into the + * hash table. * *---------------------------------------------------------------------- */ Tcl_Channel -Tcl_CreateChannel( - const Tcl_ChannelType *typePtr, /* The channel type record. */ - const char *chanName, /* Name of channel to record. */ - ClientData instanceData, /* Instance specific data. */ - int mask) /* TCL_READABLE & TCL_WRITABLE to indicate if - * the channel is readable, writable. */ +Tcl_CreateChannel(typePtr, chanName, instanceData, mask) + Tcl_ChannelType *typePtr; /* The channel type record. */ + CONST char *chanName; /* Name of channel to record. */ + ClientData instanceData; /* Instance specific data. */ + int mask; /* TCL_READABLE & TCL_WRITABLE to indicate + * if the channel is readable, writable. */ { Channel *chanPtr; /* The channel structure newly created. */ - ChannelState *statePtr; /* The stack-level independent state info for - * the channel. */ - const char *name; - char *tmp; + ChannelState *statePtr; /* The stack-level independent state info + * for the channel. */ + CONST char *name; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); /* @@ -1365,73 +1143,59 @@ Tcl_CreateChannel( * 8.3.2+, we have to make sure that our assumption that the structure * remains a binary compatible size is true. * - * If this assertion fails on some system, then it can be removed only if - * the user recompiles code with older channel drivers in the new system - * as well. + * If this assertion fails on some system, then it can be removed + * only if the user recompiles code with older channel drivers in + * the new system as well. */ - assert(sizeof(Tcl_ChannelTypeVersion) == sizeof(Tcl_DriverBlockModeProc *)); + assert(sizeof(Tcl_ChannelTypeVersion) == sizeof(Tcl_DriverBlockModeProc*)); /* - * JH: We could subsequently memset these to 0 to avoid the numerous - * assignments to 0/NULL below. + * JH: We could subsequently memset these to 0 to avoid the + * numerous assignments to 0/NULL below. */ - - chanPtr = ckalloc(sizeof(Channel)); - statePtr = ckalloc(sizeof(ChannelState)); + chanPtr = (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 * information for the channel. */ - if (chanName != NULL) { - unsigned len = strlen(chanName) + 1; - - /* - * Make sure we allocate at least 7 bytes, so it fits for "stdout" - * later. - */ - - tmp = ckalloc((len < 7) ? 7 : len); - strcpy(tmp, chanName); + if (chanName != (char *) NULL) { + char *tmp = ckalloc((unsigned) (strlen(chanName) + 1)); + statePtr->channelName = tmp; + strcpy(tmp, chanName); } else { - tmp = ckalloc(7); - tmp[0] = '\0'; + panic("Tcl_CreateChannel: NULL channel name"); } - statePtr->channelName = tmp; - statePtr->flags = mask; + + statePtr->flags = mask; /* * Set the channel to system default encoding. - * - * Note the strange bit of protection taking place here. If the system - * encoding name is reported back as "binary", something weird is - * happening. Tcl provides no "binary" encoding, so someone else has - * provided one. We ignore it so as not to interfere with the "magic" - * interpretation that Tcl_Channels give to the "-encoding binary" option. */ statePtr->encoding = NULL; name = Tcl_GetEncodingName(NULL); if (strcmp(name, "binary") != 0) { - statePtr->encoding = Tcl_GetEncoding(NULL, name); + statePtr->encoding = Tcl_GetEncoding(NULL, name); } - statePtr->inputEncodingState = NULL; - statePtr->inputEncodingFlags = TCL_ENCODING_START; - statePtr->outputEncodingState = NULL; - statePtr->outputEncodingFlags = TCL_ENCODING_START; + statePtr->inputEncodingState = NULL; + statePtr->inputEncodingFlags = TCL_ENCODING_START; + statePtr->outputEncodingState = NULL; + statePtr->outputEncodingFlags = TCL_ENCODING_START; /* - * Set the channel up initially in AUTO input translation mode to accept - * "\n", "\r" and "\r\n". Output translation mode is set to a platform - * specific default value. The eofChar is set to 0 for both input and - * output, so that Tcl does not look for an in-file EOF indicator (e.g. - * ^Z) and does not append an EOF indicator to files. + * Set the channel up initially in AUTO input translation mode to + * accept "\n", "\r" and "\r\n". Output translation mode is set to + * a platform specific default value. The eofChar is set to 0 for both + * input and output, so that Tcl does not look for an in-file EOF + * indicator (e.g. ^Z) and does not append an EOF indicator to files. */ statePtr->inputTranslation = TCL_TRANSLATE_AUTO; @@ -1441,84 +1205,76 @@ Tcl_CreateChannel( statePtr->unreportedError = 0; statePtr->refCount = 0; - statePtr->closeCbPtr = NULL; - statePtr->curOutPtr = NULL; - statePtr->outQueueHead = NULL; - statePtr->outQueueTail = NULL; - statePtr->saveInBufPtr = NULL; - statePtr->inQueueHead = NULL; - statePtr->inQueueTail = NULL; - statePtr->chPtr = NULL; + statePtr->closeCbPtr = (CloseCallback *) NULL; + statePtr->curOutPtr = (ChannelBuffer *) NULL; + statePtr->outQueueHead = (ChannelBuffer *) NULL; + statePtr->outQueueTail = (ChannelBuffer *) NULL; + statePtr->saveInBufPtr = (ChannelBuffer *) NULL; + statePtr->inQueueHead = (ChannelBuffer *) NULL; + statePtr->inQueueTail = (ChannelBuffer *) NULL; + statePtr->chPtr = (ChannelHandler *) NULL; statePtr->interestMask = 0; - statePtr->scriptRecordPtr = NULL; + statePtr->scriptRecordPtr = (EventScriptRecord *) NULL; statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE; statePtr->timer = NULL; statePtr->csPtrR = NULL; statePtr->csPtrW = NULL; statePtr->outputStage = NULL; - if ((statePtr->encoding != NULL) && GotFlag(statePtr, TCL_WRITABLE)) { - statePtr->outputStage = ckalloc(statePtr->bufSize + 2); + if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { + statePtr->outputStage = (char *) + ckalloc((unsigned) (statePtr->bufSize + 2)); } /* - * As we are creating the channel, it is obviously the top for now. + * As we are creating the channel, it is obviously the top for now */ - statePtr->topChanPtr = chanPtr; statePtr->bottomChanPtr = chanPtr; - chanPtr->downChanPtr = NULL; - chanPtr->upChanPtr = NULL; - chanPtr->inQueueHead = NULL; - chanPtr->inQueueTail = NULL; - - /* - * TIP #219, Tcl Channel Reflection API - */ - - statePtr->chanMsg = NULL; - statePtr->unreportedMsg = NULL; + chanPtr->downChanPtr = (Channel *) NULL; + chanPtr->upChanPtr = (Channel *) NULL; + chanPtr->inQueueHead = (ChannelBuffer*) NULL; + chanPtr->inQueueTail = (ChannelBuffer*) NULL; /* * Link the channel into the list of all channels; create an on-exit - * handler if there is not one already, to close off all the channels in - * the list on exit. + * handler if there is not one already, to close off all the channels + * in the list on exit. * * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check. * * TIP #218. * AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel - * We need Tcl_SpliceChannel, for the threadAction calls. There is no - * real reason to duplicate all of this. + * We need Tcl_SpliceChannel, for the threadAction calls. + * There is no real reason to duplicate all of this. * NOTE: All drivers using thread actions now have to perform their TSD - * manipulation only in their thread action proc. Doing it when - * creating their instance structures will collide with the thread - * action activity and lead to damaged lists. + * manipulation only in their thread action proc. Doing it when + * creating their instance structures will collide with the thread + * action activity and lead to damaged lists. */ - statePtr->nextCSPtr = NULL; - SpliceChannel((Tcl_Channel) chanPtr); + statePtr->nextCSPtr = (ChannelState *) NULL; + Tcl_SpliceChannel ((Tcl_Channel) chanPtr); /* - * Install this channel in the first empty standard channel slot, if the - * channel was previously closed explicitly. + * Install this channel in the first empty standard channel slot, if + * the channel was previously closed explicitly. */ - - if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) { - strcpy(tmp, "stdin"); +#if TCL_INHERIT_STD_CHANNELS + if ((tsdPtr->stdinChannel == NULL) && + (tsdPtr->stdinInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN); - Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else if ((tsdPtr->stdoutChannel == NULL) && (tsdPtr->stdoutInitialized == 1)) { - strcpy(tmp, "stdout"); Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT); - Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else if ((tsdPtr->stderrChannel == NULL) && (tsdPtr->stderrInitialized == 1)) { - strcpy(tmp, "stderr"); Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR); - Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } +#endif return (Tcl_Channel) chanPtr; } @@ -1527,52 +1283,53 @@ Tcl_CreateChannel( * * Tcl_StackChannel -- * - * Replaces an entry in the hash table for a Tcl_Channel record. The - * replacement is a new channel with same name, it supercedes the - * replaced channel. Input and output of the superceded channel is now - * going through the newly created channel and allows the arbitrary - * filtering/manipulation of the dataflow. + * Replaces an entry in the hash table for a Tcl_Channel + * record. The replacement is a new channel with same name, + * it supercedes the replaced channel. Input and output of + * the superceded channel is now going through the newly + * created channel and allows the arbitrary filtering/manipulation + * of the dataflow. * - * Andreas Kupries <a.kupries@westend.com>, 12/13/1998 "Trf-Patch for - * filtering channels" + * Andreas Kupries <a.kupries@westend.com>, 12/13/1998 + * "Trf-Patch for filtering channels" * * Results: - * Returns the new Tcl_Channel, which actually contains the saved - * information about prevChan. + * Returns the new Tcl_Channel, which actually contains the + * saved information about prevChan. * * Side effects: - * A new channel structure is allocated and linked below the existing - * channel. The channel operations and client data of the existing - * channel are copied down to the newly created channel, and the current - * channel has its operations replaced by the new typePtr. + * A new channel structure is allocated and linked below + * the existing channel. The channel operations and client + * data of the existing channel are copied down to the newly + * created channel, and the current channel has its operations + * replaced by the new typePtr. * *---------------------------------------------------------------------- */ Tcl_Channel -Tcl_StackChannel( - Tcl_Interp *interp, /* The interpreter we are working in */ - const Tcl_ChannelType *typePtr, - /* The channel type record for the new - * channel. */ - ClientData instanceData, /* Instance specific data for the new - * channel. */ - int mask, /* TCL_READABLE & TCL_WRITABLE to indicate if - * the channel is readable, writable. */ - Tcl_Channel prevChan) /* The channel structure to replace */ -{ - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - Channel *chanPtr, *prevChanPtr; - ChannelState *statePtr; - - /* - * Find the given channel (prevChan) in the list of all channels. If we do - * not find it, then it was never registered correctly. +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 */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + Channel *chanPtr, *prevChanPtr; + ChannelState *statePtr; + + /* + * Find the given channel in the list of all channels. + * If we don't find it, then it was never registered correctly. * * This operation should occur at the top of a channel stack. */ - statePtr = (ChannelState *) tsdPtr->firstCSPtr; + statePtr = (ChannelState *) tsdPtr->firstCSPtr; prevChanPtr = ((Channel *) prevChan)->state->topChanPtr; while ((statePtr != NULL) && (statePtr->topChanPtr != prevChanPtr)) { @@ -1582,21 +1339,21 @@ Tcl_StackChannel( if (statePtr == NULL) { if (interp) { Tcl_AppendResult(interp, "couldn't find state for channel \"", - Tcl_GetChannelName(prevChan), "\"", NULL); + Tcl_GetChannelName(prevChan), "\"", (char *) NULL); } - return NULL; + return (Tcl_Channel) NULL; } /* - * Here we check if the given "mask" matches the "flags" of the already - * existing channel. + * Here we check if the given "mask" matches the "flags" + * of the already existing channel. * * | - | R | W | RW | * --+---+---+---+----+ <=> 0 != (chan->mask & prevChan->mask) * - | | | | | - * R | | + | | + | The superceding channel is allowed to restrict - * W | | | + | + | the capabilities of the superceded one! - * RW| | + | + | + | + * R | | + | | + | The superceding channel is allowed to + * W | | | + | + | restrict the capabilities of the + * RW| | + | + | + | superceded one ! * --+---+---+---+----+ */ @@ -1604,76 +1361,80 @@ Tcl_StackChannel( if (interp) { Tcl_AppendResult(interp, "reading and writing both disallowed for channel \"", - Tcl_GetChannelName(prevChan), "\"", NULL); + Tcl_GetChannelName(prevChan), "\"", (char *) NULL); } - return NULL; + return (Tcl_Channel) NULL; } /* - * Flush the buffers. This ensures that any data still in them at this - * time is not handled by the new transformation. Restrict this to - * writable channels. Take care to hide a possible bg-copy in progress - * from Tcl_Flush and the CheckForChannelErrors inside. + * Flush the buffers. This ensures that any data still in them + * at this time is not handled by the new transformation. Restrict + * this to writable channels. Take care to hide a possible bg-copy + * in progress from Tcl_Flush and the CheckForChannelErrors inside. */ if ((mask & TCL_WRITABLE) != 0) { - CopyState *csPtrR = statePtr->csPtrR; - CopyState *csPtrW = statePtr->csPtrW; + CopyState *csPtrR; + CopyState *csPtrW; + + csPtrR = statePtr->csPtrR; + statePtr->csPtrR = (CopyState*) NULL; - statePtr->csPtrR = NULL; - statePtr->csPtrW = NULL; + csPtrW = statePtr->csPtrW; + statePtr->csPtrW = (CopyState*) NULL; if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) { - statePtr->csPtrR = csPtrR; + statePtr->csPtrR = csPtrR; statePtr->csPtrW = csPtrW; if (interp) { Tcl_AppendResult(interp, "could not flush channel \"", - Tcl_GetChannelName(prevChan), "\"", NULL); + Tcl_GetChannelName(prevChan), "\"", (char *) NULL); } - return NULL; + return (Tcl_Channel) NULL; } - statePtr->csPtrR = csPtrR; + statePtr->csPtrR = csPtrR; statePtr->csPtrW = csPtrW; } - /* - * Discard any input in the buffers. They are not yet read by the user of - * the channel, so they have to go through the new transformation before - * reading. As the buffers contain the untransformed form their contents - * are not only useless but actually distorts our view of the system. + * Discard any input in the buffers. They are not yet read by the + * user of the channel, so they have to go through the new + * transformation before reading. As the buffers contain the + * untransformed form their contents are not only useless but actually + * distorts our view of the system. * - * To preserve the information without having to read them again and to - * avoid problems with the location in the channel (seeking might be - * impossible) we move the buffers from the common state structure into - * the channel itself. We use the buffers in the channel below the new - * transformation to hold the data. In the future this allows us to write - * transformations which pre-read data and push the unused part back when - * they are going away. + * To preserve the information without having to read them again and + * to avoid problems with the location in the channel (seeking might + * be impossible) we move the buffers from the common state structure + * into the channel itself. We use the buffers in the channel below + * the new transformation to hold the data. In the future this allows + * us to write transformations which pre-read data and push the unused + * part back when they are going away. */ - if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) { - /* - * Remark: It is possible that the channel buffers contain data from - * some earlier push-backs. - */ + 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->inQueueTail->nextPtr = prevChanPtr->inQueueHead; - prevChanPtr->inQueueHead = statePtr->inQueueHead; + statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead; + prevChanPtr->inQueueHead = statePtr->inQueueHead; - if (prevChanPtr->inQueueTail == NULL) { - prevChanPtr->inQueueTail = statePtr->inQueueTail; - } + if (prevChanPtr->inQueueTail == (ChannelBuffer*) NULL) { + prevChanPtr->inQueueTail = statePtr->inQueueTail; + } - statePtr->inQueueHead = NULL; - statePtr->inQueueTail = NULL; + statePtr->inQueueHead = (ChannelBuffer*) NULL; + statePtr->inQueueTail = (ChannelBuffer*) NULL; } - chanPtr = ckalloc(sizeof(Channel)); + chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); /* - * Save some of the current state into the new structure, reinitialize the - * parts which will stay with the transformation. + * Save some of the current state into the new structure, + * reinitialize the parts which will stay with the transformation. * * Remarks: */ @@ -1682,9 +1443,9 @@ Tcl_StackChannel( chanPtr->instanceData = instanceData; chanPtr->typePtr = typePtr; chanPtr->downChanPtr = prevChanPtr; - chanPtr->upChanPtr = NULL; - chanPtr->inQueueHead = NULL; - chanPtr->inQueueTail = NULL; + chanPtr->upChanPtr = (Channel *) NULL; + chanPtr->inQueueHead = (ChannelBuffer*) NULL; + chanPtr->inQueueTail = (ChannelBuffer*) NULL; /* * Place new block at the head of a possibly existing list of previously @@ -1694,19 +1455,6 @@ Tcl_StackChannel( prevChanPtr->upChanPtr = chanPtr; statePtr->topChanPtr = chanPtr; - /* - * TIP #218, Channel Thread Actions. - * - * We call the thread actions for the new channel directly. We _cannot_ - * use SpliceChannel, because the (thread-)global list of all channels - * always contains the _ChannelState_ for a stack of channels, not the - * individual channels. And SpliceChannel would not only call the thread - * actions, but also add the shared ChannelState to this list a second - * time, mangling it. - */ - - ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT); - return (Tcl_Channel) chanPtr; } @@ -1715,25 +1463,25 @@ Tcl_StackChannel( * * Tcl_UnstackChannel -- * - * Unstacks an entry in the hash table for a Tcl_Channel record. This is - * the reverse to 'Tcl_StackChannel'. + * Unstacks an entry in the hash table for a Tcl_Channel + * record. This is the reverse to 'Tcl_StackChannel'. * * Results: * A standard Tcl result. * * Side effects: - * If TCL_ERROR is returned, the posix error code will be set with - * Tcl_SetErrno. May leave a message in interp result as well. + * If TCL_ERROR is returned, the posix error code will be set + * with Tcl_SetErrno. * *---------------------------------------------------------------------- */ int -Tcl_UnstackChannel( - Tcl_Interp *interp, /* The interpreter we are working in */ - Tcl_Channel chan) /* The channel to unstack */ +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; @@ -1743,47 +1491,40 @@ Tcl_UnstackChannel( chanPtr = statePtr->topChanPtr; - if (chanPtr->downChanPtr != NULL) { - /* + 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. + * 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; /* - * Flush the buffers. This ensures that any data still in them at this - * time _is_ handled by the transformation we are unstacking right - * now. Restrict this to writable channels. Take care to hide a - * possible bg-copy in progress from Tcl_Flush and the + * Flush the buffers. This ensures that any data still in them + * at this time _is_ handled by the transformation we are unstacking + * right now. Restrict this to writable channels. Take care to hide + * a possible bg-copy in progress from Tcl_Flush and the * CheckForChannelErrors inside. */ - if (GotFlag(statePtr, TCL_WRITABLE)) { - CopyState *csPtrR = statePtr->csPtrR; - CopyState *csPtrW = statePtr->csPtrW; + if (statePtr->flags & TCL_WRITABLE) { + CopyState *csPtrR; + CopyState *csPtrW; + + csPtrR = statePtr->csPtrR; + statePtr->csPtrR = (CopyState*) NULL; - statePtr->csPtrR = NULL; - statePtr->csPtrW = NULL; + csPtrW = statePtr->csPtrW; + statePtr->csPtrW = (CopyState*) NULL; if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) { - statePtr->csPtrR = csPtrR; + statePtr->csPtrR = csPtrR; statePtr->csPtrW = csPtrW; - - /* - * TIP #219, Tcl Channel Reflection API. - * Move error messages put by the driver into the chan/ip - * bypass area into the regular interpreter result. Fall back - * to the regular message if nothing was found in the - * bypasses. - */ - - if (!TclChanCaughtErrorBypass(interp, chan) && interp) { + if (interp) { Tcl_AppendResult(interp, "could not flush channel \"", Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"", - NULL); + (char *) NULL); } return TCL_ERROR; } @@ -1793,106 +1534,78 @@ Tcl_UnstackChannel( } /* - * Anything in the input queue and the push-back buffers of the - * transformation going away is transformed data, but not yet read. As - * unstacking means that the caller does not want to see transformed - * data any more we have to discard these bytes. To avoid writing an - * analogue to 'DiscardInputQueued' we move the information in the - * push back buffers to the input queue and then call - * 'DiscardInputQueued' on that. + * Anything in the input queue and the push-back buffers of + * the transformation going away is transformed data, but not + * yet read. As unstacking means that the caller does not want + * to see transformed data any more we have to discard these + * bytes. To avoid writing an analogue to 'DiscardInputQueued' + * we move the information in the push back buffers to the + * input queue and then call 'DiscardInputQueued' on that. */ - if (GotFlag(statePtr, TCL_READABLE) && - ((statePtr->inQueueHead != NULL) || - (chanPtr->inQueueHead != NULL))) { - if ((statePtr->inQueueHead != NULL) && - (chanPtr->inQueueHead != NULL)) { - statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead; + 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; statePtr->inQueueTail = chanPtr->inQueueTail; - statePtr->inQueueHead = statePtr->inQueueTail; - } else if (chanPtr->inQueueHead != NULL) { - statePtr->inQueueHead = chanPtr->inQueueHead; + statePtr->inQueueHead = statePtr->inQueueTail; + + } else if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) { + statePtr->inQueueHead = chanPtr->inQueueHead; statePtr->inQueueTail = chanPtr->inQueueTail; } - chanPtr->inQueueHead = NULL; - chanPtr->inQueueTail = NULL; + chanPtr->inQueueHead = (ChannelBuffer*) NULL; + chanPtr->inQueueTail = (ChannelBuffer*) NULL; - DiscardInputQueued(statePtr, 0); + DiscardInputQueued (statePtr, 0); } - /* - * TIP #218, Channel Thread Actions. - * - * We call the thread actions for the new channel directly. We - * _cannot_ use CutChannel, because the (thread-)global list of all - * channels always contains the _ChannelState_ for a stack of - * channels, not the individual channels. And SpliceChannel would not - * only call the thread actions, but also remove the shared - * ChannelState from this list despite there being more channels for - * the state which are still active. - */ - - ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE); - - statePtr->topChanPtr = downChanPtr; - downChanPtr->upChanPtr = NULL; + statePtr->topChanPtr = downChanPtr; + downChanPtr->upChanPtr = (Channel *) NULL; /* * Leave this link intact for closeproc - * chanPtr->downChanPtr = NULL; + * chanPtr->downChanPtr = (Channel *) NULL; */ /* * Close and free the channel driver state. */ - result = ChanClose(chanPtr, interp); - chanPtr->typePtr = NULL; + if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { + result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, + interp); + } else { + result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, + interp, 0); + } + chanPtr->typePtr = NULL; /* * AK: Tcl_NotifyChannel may hold a reference to this block of memory */ - - Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC); + Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC); UpdateInterest(downChanPtr); if (result != 0) { Tcl_SetErrno(result); - - /* - * TIP #219, Tcl Channel Reflection API. - * Move error messages put by the driver into the chan/ip bypass - * area into the regular interpreter result. - */ - - TclChanCaughtErrorBypass(interp, chan); return TCL_ERROR; } } else { - /* - * This channel does not cover another one. Simply do a close, if - * necessary. + /* + * This channel does not cover another one. + * Simply do a close, if necessary. */ - if (statePtr->refCount <= 0) { - if (Tcl_Close(interp, chan) != TCL_OK) { - /* - * TIP #219, Tcl Channel Reflection API. - * "TclChanCaughtErrorBypass" is not required here, it was - * done already by "Tcl_Close". - */ - - return TCL_ERROR; - } + if (statePtr->refCount <= 0) { + if (Tcl_Close(interp, chan) != TCL_OK) { + return TCL_ERROR; + } } - - /* - * TIP #218, Channel Thread Actions. - * Not required in this branch, this is done by Tcl_Close. If - * Tcl_Close is not called then the ChannelState is still active in - * the thread and no action has to be taken either. - */ } return TCL_OK; @@ -1906,9 +1619,9 @@ Tcl_UnstackChannel( * Determines whether the specified channel is stacked upon another. * * Results: - * NULL if the channel is not stacked upon another one, or a reference to - * the channel it is stacked upon. This reference can be used in queries, - * but modification is not allowed. + * NULL if the channel is not stacked upon another one, or a reference + * to the channel it is stacked upon. This reference can be used in + * queries, but modification is not allowed. * * Side effects: * None. @@ -1917,11 +1630,10 @@ Tcl_UnstackChannel( */ Tcl_Channel -Tcl_GetStackedChannel( - Tcl_Channel chan) +Tcl_GetStackedChannel(chan) + Tcl_Channel chan; { - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ return (Tcl_Channel) chanPtr->downChanPtr; } @@ -1934,9 +1646,9 @@ Tcl_GetStackedChannel( * Returns the top channel of a channel stack. * * Results: - * NULL if the channel is not stacked upon another one, or a reference to - * the channel it is stacked upon. This reference can be used in queries, - * but modification is not allowed. + * NULL if the channel is not stacked upon another one, or a reference + * to the channel it is stacked upon. This reference can be used in + * queries, but modification is not allowed. * * Side effects: * None. @@ -1945,11 +1657,10 @@ Tcl_GetStackedChannel( */ Tcl_Channel -Tcl_GetTopChannel( - Tcl_Channel chan) +Tcl_GetTopChannel(chan) + Tcl_Channel chan; { - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ return (Tcl_Channel) chanPtr->state->topChanPtr; } @@ -1971,11 +1682,10 @@ Tcl_GetTopChannel( */ ClientData -Tcl_GetChannelInstanceData( - Tcl_Channel chan) /* Channel for which to return client data. */ +Tcl_GetChannelInstanceData(chan) + Tcl_Channel chan; /* Channel for which to return client data. */ { - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ return chanPtr->instanceData; } @@ -1985,7 +1695,8 @@ Tcl_GetChannelInstanceData( * * Tcl_GetChannelThread -- * - * Given a channel structure, returns the thread managing it. TIP #10 + * Given a channel structure, returns the thread managing it. + * TIP #10 * * Results: * Returns the id of the thread managing the channel. @@ -1997,12 +1708,10 @@ Tcl_GetChannelInstanceData( */ Tcl_ThreadId -Tcl_GetChannelThread( - Tcl_Channel chan) /* The channel to return the managing thread - * for. */ +Tcl_GetChannelThread(chan) + Tcl_Channel chan; /* The channel to return managing thread for. */ { - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ return chanPtr->state->managingThread; } @@ -2023,12 +1732,11 @@ Tcl_GetChannelThread( *---------------------------------------------------------------------- */ -const Tcl_ChannelType * -Tcl_GetChannelType( - Tcl_Channel chan) /* The channel to return type for. */ +Tcl_ChannelType * +Tcl_GetChannelType(chan) + Tcl_Channel chan; /* The channel to return type for. */ { - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ return chanPtr->typePtr; } @@ -2038,8 +1746,8 @@ Tcl_GetChannelType( * * Tcl_GetChannelMode -- * - * Computes a mask indicating whether the channel is open for reading and - * writing. + * Computes a mask indicating whether the channel is open for + * reading and writing. * * Results: * An OR-ed combination of TCL_READABLE and TCL_WRITABLE. @@ -2051,12 +1759,12 @@ Tcl_GetChannelType( */ int -Tcl_GetChannelMode( - Tcl_Channel chan) /* The channel for which the mode is being - * computed. */ +Tcl_GetChannelMode(chan) + Tcl_Channel chan; /* The channel for which the mode is + * being computed. */ { ChannelState *statePtr = ((Channel *) chan)->state; - /* State of actual channel. */ + /* State of actual channel. */ return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE)); } @@ -2069,8 +1777,9 @@ Tcl_GetChannelMode( * Returns the string identifying the channel name. * * Results: - * The string containing the channel name. This memory is owned by the - * generic layer and should not be modified by the caller. + * The string containing the channel name. This memory is + * owned by the generic layer and should not be modified by + * the caller. * * Side effects: * None. @@ -2078,13 +1787,13 @@ Tcl_GetChannelMode( *---------------------------------------------------------------------- */ -const char * -Tcl_GetChannelName( - Tcl_Channel chan) /* The channel for which to return the name. */ +CONST char * +Tcl_GetChannelName(chan) + Tcl_Channel chan; /* The channel for which to return the name. */ { - ChannelState *statePtr = ((Channel *) chan)->state; - /* State of actual channel. */ + ChannelState *statePtr; /* State of actual channel. */ + statePtr = ((Channel *) chan)->state; return statePtr->channelName; } @@ -2106,24 +1815,18 @@ Tcl_GetChannelName( */ int -Tcl_GetChannelHandle( - Tcl_Channel chan, /* The channel to get file from. */ - int direction, /* TCL_WRITABLE or TCL_READABLE. */ - ClientData *handlePtr) /* Where to store handle */ +Tcl_GetChannelHandle(chan, direction, handlePtr) + Tcl_Channel chan; /* The channel to get file from. */ + int direction; /* TCL_WRITABLE or TCL_READABLE. */ + ClientData *handlePtr; /* Where to store handle */ { Channel *chanPtr; /* The actual channel. */ ClientData handle; int result; chanPtr = ((Channel *) chan)->state->bottomChanPtr; - if (!chanPtr->typePtr->getHandleProc) { - Tcl_SetChannelError(chan, Tcl_ObjPrintf( - "channel \"%s\" does not support OS handles", - Tcl_GetChannelName(chan))); - return TCL_ERROR; - } - result = chanPtr->typePtr->getHandleProc(chanPtr->instanceData, direction, - &handle); + result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData, + direction, &handle); if (handlePtr) { *handlePtr = handle; } @@ -2135,15 +1838,16 @@ Tcl_GetChannelHandle( * * AllocChannelBuffer -- * - * A channel buffer has BUFFER_PADDING bytes extra at beginning to hold - * any bytes of a native-encoding character that got split by the end of - * the previous buffer and need to be moved to the beginning of the next - * buffer to make a contiguous string so it can be converted to UTF-8. + * A channel buffer has BUFFER_PADDING bytes extra at beginning to + * hold any bytes of a native-encoding character that got split by + * the end of the previous buffer and need to be moved to the + * beginning of the next buffer to make a contiguous string so it + * can be converted to UTF-8. * - * A channel buffer has BUFFER_PADDING bytes extra at the end to hold any - * bytes of a native-encoding character (generated from a UTF-8 - * character) that overflow past the end of the buffer and need to be - * moved to the next buffer. + * A channel buffer has BUFFER_PADDING bytes extra at the end to + * hold any bytes of a native-encoding character (generated from a + * UTF-8 character) that overflow past the end of the buffer and + * need to be moved to the next buffer. * * Results: * A newly allocated channel buffer. @@ -2155,18 +1859,18 @@ Tcl_GetChannelHandle( */ static ChannelBuffer * -AllocChannelBuffer( - int length) /* Desired length of channel buffer. */ +AllocChannelBuffer(length) + int length; /* Desired length of channel buffer. */ { ChannelBuffer *bufPtr; int n; n = length + CHANNELBUFFER_HEADER_SIZE + BUFFER_PADDING + BUFFER_PADDING; - bufPtr = ckalloc(n); + bufPtr = (ChannelBuffer *) ckalloc((unsigned) n); bufPtr->nextAdded = BUFFER_PADDING; bufPtr->nextRemoved = BUFFER_PADDING; bufPtr->bufLength = length + BUFFER_PADDING; - bufPtr->nextPtr = NULL; + bufPtr->nextPtr = (ChannelBuffer *) NULL; return bufPtr; } @@ -2175,10 +1879,11 @@ AllocChannelBuffer( * * RecycleBuffer -- * - * Helper function to recycle input and output buffers. Ensures that two - * input buffers are saved (one in the input queue and another in the - * saveInBufPtr field) and that curOutPtr is set to a buffer. Only if - * these conditions are met is the buffer freed to the OS. + * Helper function to recycle input and output buffers. Ensures + * that two input buffers are saved (one in the input queue and + * another in the saveInBufPtr field) and that curOutPtr is set + * to a buffer. Only if these conditions are met is the buffer + * freed to the OS. * * Results: * None. @@ -2190,70 +1895,70 @@ AllocChannelBuffer( */ static void -RecycleBuffer( - ChannelState *statePtr, /* ChannelState in which to recycle buffers. */ - ChannelBuffer *bufPtr, /* The buffer to recycle. */ - int mustDiscard) /* If nonzero, free the buffer to the OS, - * always. */ +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. */ { /* * Do we have to free the buffer to the OS? */ if (mustDiscard) { - ckfree(bufPtr); - return; + ckfree((char *) bufPtr); + return; } /* - * Only save buffers which are at least as big as the requested buffersize - * for the channel. This is to honor dynamic changes of the buffersize - * made by the user. + * Only save buffers which are at least as big as the requested + * buffersize for the channel. This is to honor dynamic changes + * of the buffersize made by the user. */ if ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize) { - ckfree(bufPtr); - return; + ckfree((char *) bufPtr); + return; } /* * Only save buffers for the input queue if the channel is readable. */ - - if (GotFlag(statePtr, TCL_READABLE)) { - if (statePtr->inQueueHead == NULL) { - statePtr->inQueueHead = bufPtr; - statePtr->inQueueTail = bufPtr; - goto keepBuffer; - } - if (statePtr->saveInBufPtr == NULL) { - statePtr->saveInBufPtr = bufPtr; - goto keepBuffer; - } + + 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; + } } /* * Only save buffers for the output queue if the channel is writable. */ - if (GotFlag(statePtr, TCL_WRITABLE)) { - if (statePtr->curOutPtr == NULL) { - statePtr->curOutPtr = bufPtr; - goto keepBuffer; - } + if (statePtr->flags & TCL_WRITABLE) { + if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { + statePtr->curOutPtr = bufPtr; + goto keepit; + } } /* * If we reached this code we return the buffer to the OS. */ - ckfree(bufPtr); + ckfree((char *) bufPtr); return; - keepBuffer: + keepit: bufPtr->nextRemoved = BUFFER_PADDING; bufPtr->nextAdded = BUFFER_PADDING; - bufPtr->nextPtr = NULL; + bufPtr->nextPtr = (ChannelBuffer *) NULL; } /* @@ -2273,18 +1978,18 @@ RecycleBuffer( */ static void -DiscardOutputQueued( - ChannelState *statePtr) /* ChannelState for which to discard output. */ +DiscardOutputQueued(statePtr) + ChannelState *statePtr; /* ChannelState for which to discard output. */ { ChannelBuffer *bufPtr; - - while (statePtr->outQueueHead != NULL) { - bufPtr = statePtr->outQueueHead; - statePtr->outQueueHead = bufPtr->nextPtr; - RecycleBuffer(statePtr, bufPtr, 0); + + while (statePtr->outQueueHead != (ChannelBuffer *) NULL) { + bufPtr = statePtr->outQueueHead; + statePtr->outQueueHead = bufPtr->nextPtr; + RecycleBuffer(statePtr, bufPtr, 0); } - statePtr->outQueueHead = NULL; - statePtr->outQueueTail = NULL; + statePtr->outQueueHead = (ChannelBuffer *) NULL; + statePtr->outQueueTail = (ChannelBuffer *) NULL; } /* @@ -2292,33 +1997,33 @@ DiscardOutputQueued( * * CheckForDeadChannel -- * - * This function checks is a given channel is Dead (a channel that has - * been closed but not yet deallocated.) + * This function checks is a given channel is Dead. + * (A channel that has been closed but not yet deallocated.) * * Results: * True (1) if channel is Dead, False (0) if channel is Ok * * Side effects: - * None + * None * *---------------------------------------------------------------------- */ static int -CheckForDeadChannel( - Tcl_Interp *interp, /* For error reporting (can be NULL) */ - ChannelState *statePtr) /* The channel state to check. */ +CheckForDeadChannel(interp, statePtr) + Tcl_Interp *interp; /* For error reporting (can be NULL) */ + ChannelState *statePtr; /* The channel state to check. */ { - if (!GotFlag(statePtr, CHANNEL_DEAD)) { - return 0; - } - - Tcl_SetErrno(EINVAL); - if (interp) { - Tcl_AppendResult(interp, "unable to access channel: invalid channel", - NULL); + if (statePtr->flags & CHANNEL_DEAD) { + Tcl_SetErrno(EINVAL); + if (interp) { + Tcl_AppendResult(interp, + "unable to access channel: invalid channel", + (char *) NULL); + } + return 1; } - return 1; + return 0; } /* @@ -2326,274 +2031,228 @@ CheckForDeadChannel( * * FlushChannel -- * - * This function flushes as much of the queued output as is possible now. - * If calledFromAsyncFlush is nonzero, it is being called in an event - * handler to flush channel output asynchronously. + * This function flushes as much of the queued output as is possible + * now. If calledFromAsyncFlush is nonzero, it is being called in an + * event handler to flush channel output asynchronously. * * Results: - * 0 if successful, else the error code that was returned by the channel - * type operation. May leave a message in the interp result. + * 0 if successful, else the error code that was returned by the + * channel type operation. * * Side effects: - * May produce output on a channel. May block indefinitely if the channel - * is synchronous. May schedule an async flush on the channel. May - * recycle memory for buffers in the output queue. + * May produce output on a channel. May block indefinitely if the + * channel is synchronous. May schedule an async flush on the channel. + * May recycle memory for buffers in the output queue. * *---------------------------------------------------------------------- */ static int -FlushChannel( - Tcl_Interp *interp, /* For error reporting during close. */ - Channel *chanPtr, /* The channel to flush on. */ - int calledFromAsyncFlush) /* If nonzero then we are being called from an - * asynchronous flush callback. */ +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. */ { ChannelState *statePtr = chanPtr->state; - /* State of the channel stack. */ - ChannelBuffer *bufPtr; /* Iterates over buffered output queue. */ - int toWrite; /* Amount of output data in current buffer - * available to be written. */ - int written; /* Amount of output data actually written in - * current round. */ - int errorCode = 0; /* Stores POSIX error codes from channel - * driver operations. */ - int wroteSome = 0; /* Set to one if any data was written to the - * driver. */ + /* State of the channel stack. */ + ChannelBuffer *bufPtr; /* Iterates over buffered output + * queue. */ + int toWrite; /* Amount of output data in current + * buffer available to be written. */ + int written; /* Amount of output data actually + * written in current round. */ + int errorCode = 0; /* Stores POSIX error codes from + * channel driver operations. */ + int wroteSome = 0; /* Set to one if any data was + * written to the driver. */ /* - * Prevent writing on a dead channel -- a channel that has been closed but - * not yet deallocated. This can occur if the exit handler for the channel - * deallocation runs before all channels are deregistered in all - * interpreters. + * Prevent writing on a dead channel -- a channel that has been closed + * but not yet deallocated. This can occur if the exit handler for the + * channel deallocation runs before all channels are deregistered in + * all interpreters. */ - - if (CheckForDeadChannel(interp, statePtr)) { - return -1; - } - + + 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. + * Loop over the queued buffers and attempt to flush as + * much as possible of the queued output to the channel. */ - Tcl_Preserve(chanPtr); 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 != NULL) && - IsBufferFull(statePtr->curOutPtr)) - || (GotFlag(statePtr, BUFFER_READY) && - (statePtr->outQueueHead == NULL))) { - ResetFlag(statePtr, BUFFER_READY); - statePtr->curOutPtr->nextPtr = NULL; - if (statePtr->outQueueHead == NULL) { - statePtr->outQueueHead = statePtr->curOutPtr; - } else { - statePtr->outQueueTail->nextPtr = statePtr->curOutPtr; - } - statePtr->outQueueTail = statePtr->curOutPtr; - statePtr->curOutPtr = NULL; - } - bufPtr = statePtr->outQueueHead; + /* + * 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 we are not being called from an async flush and an async flush - * is active, we just return without producing any output. - */ + 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 (!calledFromAsyncFlush && GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - errorCode = 0; - goto done; - } + /* + * If we are not being called from an async flush and an async + * flush is active, we just return without producing any output. + */ - /* - * If the output queue is still empty, break out of the while loop. - */ + if ((!calledFromAsyncFlush) && + (statePtr->flags & BG_FLUSH_SCHEDULED)) { + return 0; + } - if (bufPtr == NULL) { - break; /* Out of the "while (1)". */ - } + /* + * If the output queue is still empty, break out of the while loop. + */ - /* - * Produce the output on the channel. - */ + if (bufPtr == (ChannelBuffer *) NULL) { + break; /* Out of the "while (1)". */ + } - toWrite = BytesLeft(bufPtr); + /* + * Produce the output on the channel. + */ + + toWrite = bufPtr->nextAdded - bufPtr->nextRemoved; if (toWrite == 0) { - written = 0; + written = 0; } else { - written = ChanWrite(chanPtr, RemovePoint(bufPtr), toWrite, - &errorCode); + 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 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 (errorCode == EINTR) { - errorCode = 0; - continue; - } + 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 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 ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) { /* - * This used to check for CHANNEL_NONBLOCKING, and panic if - * the channel was blocking. However, it appears that setting - * stdin to -blocking 0 has some effect on the stdout when - * it's a tty channel (dup'ed underneath) + * This used to check for CHANNEL_NONBLOCKING, and panic + * if the channel was blocking. However, it appears + * that setting stdin to -blocking 0 has some effect on + * the stdout when it's a tty channel (dup'ed underneath) */ - - if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - SetFlag(statePtr, BG_FLUSH_SCHEDULED); + 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) { - /* - * TIP #219, Tcl Channel Reflection API. - * When defering the error copy a message from the bypass into - * the unreported area. Or discard it if the new error is to be - * ignored in favor of an earlier defered error. - */ + /* + * Decide whether to report the error upwards or defer it. + */ - Tcl_Obj *msg = statePtr->chanMsg; + if (calledFromAsyncFlush) { + if (statePtr->unreportedError == 0) { + statePtr->unreportedError = errorCode; + } + } else { + Tcl_SetErrno(errorCode); + if (interp != NULL) { - if (statePtr->unreportedError == 0) { - statePtr->unreportedError = errorCode; - statePtr->unreportedMsg = msg; - if (msg != NULL) { - Tcl_IncrRefCount(msg); - } - } else { /* - * An old unreported error is kept, and this error thrown - * away. + * Casting away CONST here is safe because the + * TCL_VOLATILE flag guarantees CONST treatment + * of the Posix error string. */ - statePtr->chanMsg = NULL; - if (msg != NULL) { - TclDecrRefCount(msg); - } - } - } else { - /* - * TIP #219, Tcl Channel Reflection API. - * Move error messages put by the driver into the chan bypass - * area into the regular interpreter result. Fall back to the - * regular message if nothing was found in the bypasses. - */ - - Tcl_SetErrno(errorCode); - if (interp != NULL && !TclChanCaughtErrorBypass(interp, - (Tcl_Channel) chanPtr)) { - Tcl_SetObjResult(interp, - Tcl_NewStringObj(Tcl_PosixError(interp), -1)); + Tcl_SetResult(interp, + (char *) Tcl_PosixError(interp), TCL_VOLATILE); } + } - /* - * An unreportable bypassed message is kept, for the caller of - * Tcl_Seek, Tcl_Write, etc. - */ - } - - /* - * When we get an error we throw away all the output currently - * queued. - */ + /* + * When we get an error we throw away all the output + * currently queued. + */ - DiscardOutputQueued(statePtr); - continue; - } else { + DiscardOutputQueued(statePtr); + continue; + } else { wroteSome = 1; } - if (!IsBufferEmpty(bufPtr)) { - bufPtr->nextRemoved += written; - } + bufPtr->nextRemoved += written; - /* - * If this buffer is now empty, recycle it. - */ + /* + * If this buffer is now empty, recycle it. + */ - if (IsBufferEmpty(bufPtr)) { - statePtr->outQueueHead = bufPtr->nextPtr; - if (statePtr->outQueueHead == NULL) { - statePtr->outQueueTail = NULL; - } - RecycleBuffer(statePtr, bufPtr, 0); - } + 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)". */ /* * If we wrote some data while flushing in the background, we are done. - * We can't finish the background flush until we run out of data and the - * channel becomes writable again. This ensures that all of the pending - * data has been flushed at the system level. + * We can't finish the background flush until we run out of data and + * the channel becomes writable again. This ensures that all of the + * pending data has been flushed at the system level. */ - if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + if (statePtr->flags & BG_FLUSH_SCHEDULED) { if (wroteSome) { - goto done; - } else if (statePtr->outQueueHead == NULL) { - ResetFlag(statePtr, BG_FLUSH_SCHEDULED); - ChanWatch(chanPtr, statePtr->interestMask); + return errorCode; + } else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) { + statePtr->flags &= (~(BG_FLUSH_SCHEDULED)); + (chanPtr->typePtr->watchProc)(chanPtr->instanceData, + statePtr->interestMask); } } /* - * If the channel is flagged as closed, delete it when the refCount drops - * to zero, the output queue is empty and there is no output in the - * current output buffer. + * If the channel is flagged as closed, delete it when the refCount + * drops to zero, the output queue is empty and there is no output + * in the current output buffer. */ - if (GotFlag(statePtr, CHANNEL_CLOSED) && (statePtr->refCount <= 0) && - (statePtr->outQueueHead == NULL) && - ((statePtr->curOutPtr == NULL) || - IsBufferEmpty(statePtr->curOutPtr))) { - errorCode = CloseChannel(interp, chanPtr, errorCode); - goto done; + if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) && + (statePtr->outQueueHead == (ChannelBuffer *) NULL) && + ((statePtr->curOutPtr == (ChannelBuffer *) NULL) || + (statePtr->curOutPtr->nextAdded == + statePtr->curOutPtr->nextRemoved))) { + return CloseChannel(interp, chanPtr, errorCode); } - - /* - * If the write-side of the channel is flagged as closed, delete it when - * the output queue is empty and there is no output in the current output - * buffer. - */ - - if (GotFlag(statePtr, CHANNEL_CLOSEDWRITE) && - (statePtr->outQueueHead == NULL) && - ((statePtr->curOutPtr == NULL) || - IsBufferEmpty(statePtr->curOutPtr))) { - errorCode = CloseChannelPart(interp, chanPtr, errorCode, TCL_CLOSE_WRITE); - goto done; - } - - done: - Tcl_Release(chanPtr); return errorCode; } @@ -2606,33 +2265,34 @@ FlushChannel( * * If the channel was stacked, then the it will copy the necessary * elements of the NEXT channel into the TOP channel, in essence - * unstacking the channel. The NEXT channel will then be freed. + * unstacking the channel. The NEXT channel will then be freed. * - * If the channel was not stacked, then we will free all the bits for the - * TOP channel, including the data structure itself. + * If the channel was not stacked, then we will free all the bits + * for the TOP channel, including the data structure itself. * * Results: - * Error code from an unreported error or the driver close operation. + * 1 if the channel was stacked, 0 otherwise. * * Side effects: - * May close the actual channel, may free memory, may change the value of - * errno. + * May close the actual channel; may free memory. + * May change the value of errno. * *---------------------------------------------------------------------- */ static int -CloseChannel( - Tcl_Interp *interp, /* For error reporting. */ - Channel *chanPtr, /* The channel to close. */ - int errorCode) /* Status of operation so far. */ -{ - int result = 0; /* Of calling driver close operation. */ - ChannelState *statePtr; /* State of the channel stack. */ +CloseChannel(interp, chanPtr, errorCode) + Tcl_Interp *interp; /* For error reporting. */ + Channel *chanPtr; /* The channel to close. */ + int errorCode; /* Status of operation so far. */ +{ + int result = 0; /* Of calling driver close + * operation. */ + ChannelState *statePtr; /* state of the channel stack. */ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); if (chanPtr == NULL) { - return result; + return result; } statePtr = chanPtr->state; @@ -2646,103 +2306,81 @@ CloseChannel( * Discard a leftover buffer in the current output buffer field. */ - if (statePtr->curOutPtr != NULL) { - ckfree(statePtr->curOutPtr); - statePtr->curOutPtr = NULL; + if (statePtr->curOutPtr != (ChannelBuffer *) NULL) { + ckfree((char *) statePtr->curOutPtr); + statePtr->curOutPtr = (ChannelBuffer *) NULL; } - + /* - * The caller guarantees that there are no more buffers queued for output. + * The caller guarantees that there are no more buffers + * queued for output. */ - if (statePtr->outQueueHead != NULL) { - Tcl_Panic("TclFlush, closed channel: queued output left"); + if (statePtr->outQueueHead != (ChannelBuffer *) NULL) { + panic("TclFlush, closed channel: queued output left"); } /* - * If the EOF character is set in the channel, append that to the output - * device. + * If the EOF character is set in the channel, append that to the + * output device. */ - if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) { - int dummy; - char c = (char) statePtr->outEofChar; - - (void) ChanWrite(chanPtr, &c, 1, &dummy); - } - - /* - * TIP #219, Tcl Channel Reflection API. - * Move a leftover error message in the channel bypass into the - * interpreter bypass. Just clear it if there is no interpreter. - */ + if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) { + int dummy; + char c; - if (statePtr->chanMsg != NULL) { - if (interp != NULL) { - Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); - } - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; + c = (char) statePtr->outEofChar; + (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy); } /* * Remove this channel from of the list of all channels. */ - - CutChannel((Tcl_Channel) chanPtr); + Tcl_CutChannel((Tcl_Channel) chanPtr); /* * Close and free the channel driver state. - * This may leave a TIP #219 error message in the interp. */ - result = ChanClose(chanPtr, interp); + if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { + result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp); + } else { + result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp, + 0); + } /* - * Some resources can be cleared only if the bottom channel in a stack is - * closed. All the other channels in the stack are not allowed to remove. + * Some resources can be cleared only if the bottom channel + * in a stack is closed. All the other channels in the stack + * are not allowed to remove. */ if (chanPtr == statePtr->bottomChanPtr) { - if (statePtr->channelName != NULL) { - ckfree(statePtr->channelName); + if (statePtr->channelName != (char *) NULL) { + ckfree((char *) statePtr->channelName); statePtr->channelName = NULL; } Tcl_FreeEncoding(statePtr->encoding); if (statePtr->outputStage != NULL) { - ckfree(statePtr->outputStage); - statePtr->outputStage = NULL; + ckfree((char *) statePtr->outputStage); + statePtr->outputStage = (char *) NULL; } } /* - * If we are being called synchronously, report either any latent error on - * the channel or the current error. + * If we are being called synchronously, report either + * any latent error on the channel or the current error. */ if (statePtr->unreportedError != 0) { - errorCode = statePtr->unreportedError; - - /* - * TIP #219, Tcl Channel Reflection API. - * Move an error message found in the unreported area into the regular - * bypass (interp). This kills any message in the channel bypass area. - */ - - if (statePtr->chanMsg != NULL) { - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; - } - if (interp) { - Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg); - } + errorCode = statePtr->unreportedError; } if (errorCode == 0) { - errorCode = result; - if (errorCode != 0) { - Tcl_SetErrno(errorCode); - } + errorCode = result; + if (errorCode != 0) { + Tcl_SetErrno(errorCode); + } } /* @@ -2755,31 +2393,31 @@ CloseChannel( * Mark the channel as deleted by clearing the type structure. */ - if (chanPtr->downChanPtr != NULL) { + if (chanPtr->downChanPtr != (Channel *) NULL) { Channel *downChanPtr = chanPtr->downChanPtr; - statePtr->nextCSPtr = tsdPtr->firstCSPtr; - tsdPtr->firstCSPtr = statePtr; + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; - statePtr->topChanPtr = downChanPtr; - downChanPtr->upChanPtr = NULL; - chanPtr->typePtr = NULL; + statePtr->topChanPtr = downChanPtr; + downChanPtr->upChanPtr = (Channel *) NULL; + chanPtr->typePtr = NULL; - Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC); + Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC); return Tcl_Close(interp, (Tcl_Channel) downChanPtr); } /* - * There is only the TOP Channel, so we free the remaining pointers we - * have and then ourselves. Since this is the last of the channels in the - * stack, make sure to free the ChannelState structure associated with it. - * We use Tcl_EventuallyFree to allow for any last references. + * There is only the TOP Channel, so we free the remaining + * pointers we have and then ourselves. Since this is the + * last of the channels in the stack, make sure to free the + * ChannelState structure associated with it. We use + * Tcl_EventuallyFree to allow for any last */ - chanPtr->typePtr = NULL; - Tcl_EventuallyFree(statePtr, TCL_DYNAMIC); - Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC); + Tcl_EventuallyFree((ClientData) statePtr, TCL_DYNAMIC); + Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC); return errorCode; } @@ -2788,10 +2426,10 @@ CloseChannel( *---------------------------------------------------------------------- * * Tcl_CutChannel -- - * CutChannel -- * - * Removes a channel from the (thread-)global list of all channels (in - * that thread). This is actually the statePtr for the stack of channel. + * Removes a channel from the (thread-)global list of all channels + * (in that thread). This is actually the statePtr for the stack + * of channel. * * Results: * Nothing. @@ -2800,96 +2438,56 @@ CloseChannel( * Resets the field 'nextCSPtr' of the specified channel state to NULL. * * NOTE: - * The channel to cut out of the list must not be referenced in any - * interpreter. This is something this procedure cannot check (despite - * the refcount) because the caller usually wants fiddle with the channel - * (like transfering it to a different thread) and thus keeps the - * refcount artifically high to prevent its destruction. + * The channel to cut out of the list must not be referenced + * in any interpreter. This is something this procedure cannot + * check (despite the refcount) because the caller usually wants + * fiddle with the channel (like transfering it to a different + * thread) and thus keeps the refcount artifically high to prevent + * its destruction. * *---------------------------------------------------------------------- */ -static void -CutChannel( - Tcl_Channel chan) /* The channel being removed. Must not be - * referenced in any interpreter. */ -{ - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - ChannelState *prevCSPtr; /* Preceding channel state in list of all - * states - used to splice a channel out of - * the list on close. */ - ChannelState *statePtr = ((Channel *) chan)->state; - /* State of the channel stack. */ - - /* - * Remove this channel from of the list of all channels (in the current - * thread). - */ - - if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) { - tsdPtr->firstCSPtr = statePtr->nextCSPtr; - } else { - for (prevCSPtr = tsdPtr->firstCSPtr; - prevCSPtr && (prevCSPtr->nextCSPtr != statePtr); - prevCSPtr = prevCSPtr->nextCSPtr) { - /* Empty loop body. */ - } - if (prevCSPtr == NULL) { - Tcl_Panic("FlushChannel: damaged channel list"); - } - prevCSPtr->nextCSPtr = statePtr->nextCSPtr; - } - - statePtr->nextCSPtr = NULL; - - /* - * TIP #218, Channel Thread Actions - */ - - ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_REMOVE); -} - void -Tcl_CutChannel( - Tcl_Channel chan) /* The channel being added. Must not be - * referenced in any interpreter. */ -{ - Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr; - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - ChannelState *prevCSPtr; /* Preceding channel state in list of all - * states - used to splice a channel out of - * the list on close. */ - ChannelState *statePtr = chanPtr->state; - /* State of the channel stack. */ +Tcl_CutChannel(chan) + Tcl_Channel chan; /* The channel being removed. Must + * not be referenced in any + * interpreter. */ +{ + ThreadSpecificData* tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *prevCSPtr; /* Preceding channel state in list of + * all states - used to splice a + * channel out of the list on close. */ + ChannelState *statePtr = ((Channel *) chan)->state; + /* state of the channel stack. */ + Tcl_DriverThreadActionProc *threadActionProc; /* - * Remove this channel from of the list of all channels (in the current - * thread). + * Remove this channel from of the list of all channels + * (in the current thread). */ if (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 == 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) { + panic("FlushChannel: damaged channel list"); + } + prevCSPtr->nextCSPtr = statePtr->nextCSPtr; } - statePtr->nextCSPtr = NULL; + statePtr->nextCSPtr = (ChannelState *) NULL; - /* - * TIP #218, Channel Thread Actions - * For all transformations and the base channel. - */ - - for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) { - ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE); + /* TIP #218, Channel Thread Actions */ + threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan)); + if (threadActionProc != NULL) { + (*threadActionProc) (Tcl_GetChannelInstanceData(chan), + TCL_CHANNEL_THREAD_REMOVE); } } @@ -2897,11 +2495,10 @@ Tcl_CutChannel( *---------------------------------------------------------------------- * * Tcl_SpliceChannel -- - * SpliceChannel -- * - * Adds a channel to the (thread-)global list of all channels (in that - * thread). Expects that the field 'nextChanPtr' in the channel is set to - * NULL. + * Adds a channel to the (thread-)global list of all channels + * (in that thread). Expects that the field 'nextChanPtr' in + * the channel is set to NULL. * * Results: * Nothing. @@ -2911,75 +2508,45 @@ Tcl_CutChannel( * * NOTE: * The channel to splice into the list must not be referenced in any - * interpreter. This is something this procedure cannot check (despite - * the refcount) because the caller usually wants figgle with the channel - * (like transfering it to a different thread) and thus keeps the - * refcount artifically high to prevent its destruction. + * interpreter. This is something this procedure cannot check + * (despite the refcount) because the caller usually wants figgle + * with the channel (like transfering it to a different thread) + * and thus keeps the refcount artifically high to prevent its + * destruction. * *---------------------------------------------------------------------- */ -static void -SpliceChannel( - Tcl_Channel chan) /* The channel being added. Must not be - * referenced in any interpreter. */ -{ - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - ChannelState *statePtr = ((Channel *) chan)->state; - - if (statePtr->nextCSPtr != NULL) { - Tcl_Panic("SpliceChannel: trying to add channel used in different list"); - } - - statePtr->nextCSPtr = tsdPtr->firstCSPtr; - tsdPtr->firstCSPtr = statePtr; - - /* - * TIP #10. Mark the current thread as the new one managing this channel. - * Note: 'Tcl_GetCurrentThread' returns sensible values even for - * a non-threaded core. - */ - - statePtr->managingThread = Tcl_GetCurrentThread(); - - /* - * TIP #218, Channel Thread Actions - */ - - ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_INSERT); -} - void -Tcl_SpliceChannel( - Tcl_Channel chan) /* The channel being added. Must not be - * referenced in any interpreter. */ +Tcl_SpliceChannel(chan) + Tcl_Channel chan; /* The channel being added. Must + * not be referenced in any + * interpreter. */ { - Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr; - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - ChannelState *statePtr = chanPtr->state; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *statePtr = ((Channel *) chan)->state; + Tcl_DriverThreadActionProc *threadActionProc; - if (statePtr->nextCSPtr != NULL) { - Tcl_Panic("SpliceChannel: trying to add channel used in different list"); + if (statePtr->nextCSPtr != (ChannelState *) NULL) { + 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. + * TIP #10. Mark the current thread as the new one managing this + * channel. Note: 'Tcl_GetCurrentThread' returns sensible + * values even for a non-threaded core. */ - statePtr->managingThread = Tcl_GetCurrentThread(); + statePtr->managingThread = Tcl_GetCurrentThread (); - /* - * TIP #218, Channel Thread Actions - * For all transformations and the base channel. - */ - - for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) { - ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT); + /* TIP #218, Channel Thread Actions */ + threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan)); + if (threadActionProc != NULL) { + (*threadActionProc) (Tcl_GetChannelInstanceData(chan), + TCL_CHANNEL_THREAD_INSERT); } } @@ -2998,30 +2565,29 @@ Tcl_SpliceChannel( * * NOTE: * Tcl_Close removes the channel as far as the user is concerned. - * However, it may continue to exist for a while longer if it has a - * background flush scheduled. The device itself is eventually closed and - * the channel record removed, in CloseChannel, above. + * However, it may continue to exist for a while longer if it has + * a background flush scheduled. The device itself is eventually + * closed and the channel record removed, in CloseChannel, above. * *---------------------------------------------------------------------- */ /* ARGSUSED */ int -Tcl_Close( - Tcl_Interp *interp, /* Interpreter for errors. */ - Tcl_Channel chan) /* The channel being closed. Must not be - * referenced in any interpreter. */ -{ - CloseCallback *cbPtr; /* Iterate over close callbacks for this - * channel. */ - Channel *chanPtr; /* The real IO channel. */ - ChannelState *statePtr; /* State of real IO channel. */ - int result; /* Of calling FlushChannel. */ - int flushcode; - int stickyError; +Tcl_Close(interp, chan) + Tcl_Interp *interp; /* Interpreter for errors. */ + Tcl_Channel chan; /* The channel being closed. Must + * not be referenced in any + * interpreter. */ +{ + CloseCallback *cbPtr; /* Iterate over close callbacks + * for this channel. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of real IO channel. */ + int result; /* Of calling FlushChannel. */ - if (chan == NULL) { - return TCL_OK; + if (chan == (Tcl_Channel) NULL) { + return TCL_OK; } /* @@ -3038,50 +2604,32 @@ Tcl_Close( * 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"); + panic("called Tcl_Close on channel with refCount > 0"); } - - if (GotFlag(statePtr, CHANNEL_INCLOSE)) { + + if (statePtr->flags & CHANNEL_INCLOSE) { if (interp) { - Tcl_AppendResult(interp, "Illegal recursive call to close " - "through close-handler of channel", NULL); + Tcl_AppendResult(interp, + "Illegal recursive call to close through close-handler of channel", + (char *) NULL); } - return TCL_ERROR; + return TCL_ERROR; } - SetFlag(statePtr, CHANNEL_INCLOSE); + statePtr->flags |= CHANNEL_INCLOSE; /* * When the channel has an escape sequence driven encoding such as * iso2022, the terminated escape sequence must write to the buffer. */ - - stickyError = 0; - if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL) && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) { - statePtr->outputEncodingFlags |= TCL_ENCODING_END; - if (WriteChars(chanPtr, "", 0) < 0) { - stickyError = Tcl_GetErrno(); - } - - /* - * TIP #219, Tcl Channel Reflection API. - * Move an error message found in the channel bypass into the - * interpreter bypass. Just clear it if there is no interpreter. - */ - - if (statePtr->chanMsg != NULL) { - if (interp != NULL) { - Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); - } - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; - } + statePtr->outputEncodingFlags |= TCL_ENCODING_END; + WriteChars(chanPtr, "", 0); } Tcl_ClearChannelHandlers(chan); @@ -3090,419 +2638,46 @@ Tcl_Close( * Invoke the registered close callbacks and delete their records. */ - while (statePtr->closeCbPtr != NULL) { - cbPtr = statePtr->closeCbPtr; - statePtr->closeCbPtr = cbPtr->nextPtr; - cbPtr->proc(cbPtr->clientData); - ckfree(cbPtr); + while (statePtr->closeCbPtr != (CloseCallback *) NULL) { + cbPtr = statePtr->closeCbPtr; + statePtr->closeCbPtr = cbPtr->nextPtr; + (cbPtr->proc) (cbPtr->clientData); + ckfree((char *) cbPtr); } - ResetFlag(statePtr, CHANNEL_INCLOSE); + statePtr->flags &= ~CHANNEL_INCLOSE; /* * Ensure that the last output buffer will be flushed. */ - - if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); + + if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) && + (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) { + statePtr->flags |= BUFFER_READY; } /* - * If this channel supports it, close the read side, since we don't need - * it anymore and this will help avoid deadlocks on some channel types. + * If this channel supports it, close the read side, since we don't need it + * anymore and this will help avoid deadlocks on some channel types. */ if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) { - result = chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, + result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp, TCL_CLOSE_READ); } else { result = 0; } /* - * The call to FlushChannel will flush any queued output and invoke the - * close function of the channel driver, or it will set up the channel to - * be flushed and closed asynchronously. - */ - - SetFlag(statePtr, CHANNEL_CLOSED); - - flushcode = FlushChannel(interp, chanPtr, 0); - - /* - * TIP #219. - * Capture error messages put by the driver into the bypass area and put - * them into the regular interpreter result. - * - * Notes: Due to the assertion of CHANNEL_CLOSED in the flags - * FlushChannel() has called CloseChannel() and thus freed all the channel - * structures. We must not try to access "chan" anymore, hence the NULL - * argument in the call below. The only place which may still contain a - * message is the interpreter itself, and "CloseChannel" made sure to lift - * any channel message it generated into it. - */ - - if (TclChanCaughtErrorBypass(interp, NULL)) { - result = EINVAL; - } - - if (stickyError != 0) { - Tcl_SetErrno(stickyError); - if (interp != NULL) { - Tcl_SetObjResult(interp, - Tcl_NewStringObj(Tcl_PosixError(interp), -1)); - } - flushcode = -1; - } - if ((flushcode != 0) || (result != 0)) { - return TCL_ERROR; - } - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_CloseEx -- - * - * Closes one side of a channel, read or write. - * - * Results: - * A standard Tcl result. - * - * Side effects: - * Closes one direction of the channel. - * - * NOTE: - * Tcl_CloseEx closes the specified direction of the channel as far as - * the user is concerned. The channel keeps existing however. You cannot - * calls this function to close the last possible direction of the - * channel. Use Tcl_Close for that. - * - *---------------------------------------------------------------------- - */ - - /* ARGSUSED */ -int -Tcl_CloseEx( - Tcl_Interp *interp, /* Interpreter for errors. */ - Tcl_Channel chan, /* The channel being closed. May still be used - * by some interpreter. */ - int flags) /* Flags telling us which side to close. */ -{ - Channel *chanPtr; /* The real IO channel. */ - ChannelState *statePtr; /* State of real IO channel. */ - - if (chan == NULL) { - return TCL_OK; - } - - /* TODO: assert flags validity ? */ - - chanPtr = (Channel *) chan; - statePtr = chanPtr->state; - - /* - * Does the channel support half-close anyway? Error if not. - */ - - if (!chanPtr->typePtr->close2Proc) { - Tcl_AppendResult(interp, "Half-close of channels not supported by ", - chanPtr->typePtr->typeName, "s", NULL); - return TCL_ERROR; - } - - /* - * Is the channel unstacked ? If not we fail. - */ - - if (chanPtr != statePtr->topChanPtr) { - Tcl_AppendResult(interp, - "Half-close not applicable to stack of transformations", - NULL); - return TCL_ERROR; - } - - /* - * Check direction against channel mode. It is an error if we try to close - * a direction not supported by the channel (already closed, or never - * opened for that direction). - */ - - if (!(statePtr->flags & (TCL_READABLE | TCL_WRITABLE) & flags)) { - const char *msg; - - if (flags & TCL_CLOSE_READ) { - msg = "read"; - } else { - msg = "write"; - } - Tcl_AppendResult(interp, "Half-close of ", msg, - "-side not possible, side not opened or already closed", - NULL); - return TCL_ERROR; - } - - /* - * A user may try to call half-close from within a channel close - * handler. That won't do. + * The call to FlushChannel will flush any queued output and invoke + * the close function of the channel driver, or it will set up the + * channel to be flushed and closed asynchronously. */ - if (statePtr->flags & CHANNEL_INCLOSE) { - if (interp) { - Tcl_AppendResult(interp, "Illegal recursive call to close " - "through close-handler of channel", NULL); - } - return TCL_ERROR; - } - - if (flags & TCL_CLOSE_READ) { - /* - * Call the finalization code directly. There are no events to handle, - * there cannot be for the read-side. - */ - - return CloseChannelPart(interp, chanPtr, 0, flags); - } else if (flags & TCL_CLOSE_WRITE) { - if ((statePtr->curOutPtr != NULL) && - IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); - } - Tcl_Preserve(statePtr); - if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - /* - * We don't want to re-enter CloseWrite(). - */ - - if (!GotFlag(statePtr, CHANNEL_CLOSEDWRITE)) { - if (CloseWrite(interp, chanPtr) != TCL_OK) { - SetFlag(statePtr, CHANNEL_CLOSEDWRITE); - Tcl_Release(statePtr); - return TCL_ERROR; - } - } - } - SetFlag(statePtr, CHANNEL_CLOSEDWRITE); - Tcl_Release(statePtr); - } - - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * CloseWrite -- - * - * Closes the write side a channel. - * - * Results: - * A standard Tcl result. - * - * Side effects: - * Closes the write side of the channel. - * - * NOTE: - * CloseWrite removes the channel as far as the user is concerned. - * However, the ooutput data structures may continue to exist for a while - * longer if it has a background flush scheduled. The device itself is - * eventually closed and the channel structures modified, in - * CloseChannelPart, below. - * - *---------------------------------------------------------------------- - */ - -static int -CloseWrite( - Tcl_Interp *interp, /* Interpreter for errors. */ - Channel *chanPtr) /* The channel whose write side is being - * closed. May still be used by some - * interpreter */ -{ - /* Notes: clear-channel-handlers - write side only ? or keep around, just - * not called. */ - /* No close cllbacks are run - channel is still open (read side) */ - - ChannelState *statePtr = chanPtr->state; - /* State of real IO channel. */ - int flushcode; - int result = 0; - - /* - * Ensure that the last output buffer will be flushed. - */ - - if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); - } - - /* - * The call to FlushChannel will flush any queued output and invoke the - * close function of the channel driver, or it will set up the channel to - * be flushed and closed asynchronously. - */ - - SetFlag(statePtr, CHANNEL_CLOSEDWRITE); - - flushcode = FlushChannel(interp, chanPtr, 0); - - /* - * TIP #219. - * Capture error messages put by the driver into the bypass area and put - * them into the regular interpreter result. - * - * Notes: Due to the assertion of CHANNEL_CLOSEDWRITE in the flags - * FlushChannel() has called CloseChannelPart(). While we can still access - * "chan" (no structures were freed), the only place which may still - * contain a message is the interpreter itself, and "CloseChannelPart" made - * sure to lift any channel message it generated into it. Hence the NULL - * argument in the call below. - */ - - if (TclChanCaughtErrorBypass(interp, NULL)) { - result = EINVAL; - } - - if ((flushcode != 0) || (result != 0)) { - return TCL_ERROR; - } - - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * CloseChannelPart -- - * - * Utility procedure to close a channel partially and free associated - * resources. If the channel was stacked it will never be run (The higher - * level forbid this). If the channel was not stacked, then we will free - * all the bits of the chosen side (read, or write) for the TOP channel. - * - * Results: - * Error code from an unreported error or the driver close2 operation. - * - * Side effects: - * May free memory, may change the value of errno. - * - *---------------------------------------------------------------------- - */ - -static int -CloseChannelPart( - Tcl_Interp *interp, /* Interpreter for errors. */ - Channel *chanPtr, /* The channel being closed. May still be used - * by some interpreter. */ - int errorCode, /* Status of operation so far. */ - int flags) /* Flags telling us which side to close. */ -{ - ChannelState *statePtr; /* State of real IO channel. */ - int result; /* Of calling the close2proc. */ - - statePtr = chanPtr->state; - - if (flags & TCL_CLOSE_READ) { - /* - * No more input can be consumed so discard any leftover input. - */ - - DiscardInputQueued(statePtr, 1); - } else if (flags & TCL_CLOSE_WRITE) { - /* - * The caller guarantees that there are no more buffers queued for - * output. - */ - - if (statePtr->outQueueHead != NULL) { - Tcl_Panic("ClosechanHalf, closed write-side of channel: " - "queued output left"); - } - - /* - * If the EOF character is set in the channel, append that to the - * output device. - */ - - if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) { - int dummy; - char c = (char) statePtr->outEofChar; - - (void) ChanWrite(chanPtr, &c, 1, &dummy); - } - - /* - * TIP #219, Tcl Channel Reflection API. - * Move a leftover error message in the channel bypass into the - * interpreter bypass. Just clear it if there is no interpreter. - */ - - if (statePtr->chanMsg != NULL) { - if (interp != NULL) { - Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); - } - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; - } - } - - /* - * Finally do what is asked of us. Close and free the channel driver state - * for the chosen side of the channel. This may leave a TIP #219 error - * message in the interp. - */ - - result = ChanCloseHalf(chanPtr, interp, flags); - - /* - * If we are being called synchronously, report either any latent error on - * the channel or the current error. - */ - - if (statePtr->unreportedError != 0) { - errorCode = statePtr->unreportedError; - - /* - * TIP #219, Tcl Channel Reflection API. - * Move an error message found in the unreported area into the regular - * bypass (interp). This kills any message in the channel bypass area. - */ - - if (statePtr->chanMsg != NULL) { - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; - } - if (interp) { - Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg); - } - } - if (errorCode == 0) { - errorCode = result; - if (errorCode != 0) { - Tcl_SetErrno(errorCode); - } - } - - /* - * TIP #219. - * Capture error messages put by the driver into the bypass area and put - * them into the regular interpreter result. See also the bottom of - * CloseWrite(). - */ - - if (TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) { - result = EINVAL; - } - - if (result != 0) { - return TCL_ERROR; + statePtr->flags |= CHANNEL_CLOSED; + if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) { + return TCL_ERROR; } - - /* - * Remove the closed side from the channel mode/flags. - */ - - ResetFlag(statePtr, flags & (TCL_READABLE | TCL_WRITABLE)); return TCL_OK; } @@ -3525,8 +2700,8 @@ CloseChannelPart( */ void -Tcl_ClearChannelHandlers( - Tcl_Channel channel) +Tcl_ClearChannelHandlers (channel) + Tcl_Channel channel; { ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */ EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */ @@ -3539,9 +2714,9 @@ Tcl_ClearChannelHandlers( * 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; /* * Cancel any outstanding timer. @@ -3550,27 +2725,31 @@ Tcl_ClearChannelHandlers( Tcl_DeleteTimerHandler(statePtr->timer); /* - * Remove any references to channel handlers for this channel that may be - * about to be invoked. + * Remove any references to channel handlers for this channel that + * may be about to be invoked. */ - for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL; - nhPtr = nhPtr->nestedHandlerPtr) { - if (nhPtr->nextHandlerPtr && + for (nhPtr = tsdPtr->nestedHandlerPtr; + nhPtr != (NextChannelHandler *) NULL; + nhPtr = nhPtr->nestedHandlerPtr) { + if (nhPtr->nextHandlerPtr && (nhPtr->nextHandlerPtr->chanPtr == chanPtr)) { nhPtr->nextHandlerPtr = NULL; - } + } } /* - * Remove all the channel handler records attached to the channel itself. + * Remove all the channel handler records attached to the channel + * itself. */ - for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) { - chNext = chPtr->nextPtr; - ckfree(chPtr); + for (chPtr = statePtr->chPtr; + chPtr != (ChannelHandler *) NULL; + chPtr = chNext) { + chNext = chPtr->nextPtr; + ckfree((char *) chPtr); } - statePtr->chPtr = NULL; + statePtr->chPtr = (ChannelHandler *) NULL; /* * Cancel any pending copy operation. @@ -3592,12 +2771,14 @@ Tcl_ClearChannelHandlers( * Remove any EventScript records for this channel. */ - for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) { - eNextPtr = ePtr->nextPtr; - TclDecrRefCount(ePtr->scriptPtr); - ckfree(ePtr); + for (ePtr = statePtr->scriptRecordPtr; + ePtr != (EventScriptRecord *) NULL; + ePtr = eNextPtr) { + eNextPtr = ePtr->nextPtr; + Tcl_DecrRefCount(ePtr->scriptPtr); + ckfree((char *) ePtr); } - statePtr->scriptRecordPtr = NULL; + statePtr->scriptRecordPtr = (EventScriptRecord *) NULL; } /* @@ -3605,11 +2786,11 @@ Tcl_ClearChannelHandlers( * * Tcl_Write -- * - * Puts a sequence of bytes into an output buffer, may queue the buffer - * for output if it gets full, and also remembers whether the current - * buffer is ready e.g. if it contains a newline and we are in line - * buffering mode. Compensates stacking, i.e. will redirect the data from - * the specified channel to the topmost channel in a stack. + * Puts a sequence of bytes into an output buffer, may queue the + * buffer for output if it gets full, and also remembers whether the + * current buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. Compensates stacking, i.e. will redirect the + * data from the specified channel to the topmost channel in a stack. * * No encoding conversions are applied to the bytes being read. * @@ -3625,28 +2806,27 @@ Tcl_ClearChannelHandlers( */ int -Tcl_Write( - Tcl_Channel chan, /* The channel to buffer output for. */ - const char *src, /* Data to queue in output buffer. */ - int srcLen) /* Length of data in bytes, or < 0 for - * strlen(). */ +Tcl_Write(chan, src, srcLen) + Tcl_Channel chan; /* The channel to buffer output for. */ + CONST char *src; /* Data to queue in output buffer. */ + int srcLen; /* Length of data in bytes, or < 0 for + * strlen(). */ { /* * Always use the topmost channel of the stack */ - Channel *chanPtr; - ChannelState *statePtr; /* State info for channel */ + 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); } @@ -3656,11 +2836,11 @@ Tcl_Write( * * Tcl_WriteRaw -- * - * Puts a sequence of bytes into an output buffer, may queue the buffer - * for output if it gets full, and also remembers whether the current - * buffer is ready e.g. if it contains a newline and we are in line - * buffering mode. Writes directly to the driver of the channel, does not - * compensate for stacking. + * Puts a sequence of bytes into an output buffer, may queue the + * buffer for output if it gets full, and also remembers whether the + * current buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. Writes directly to the driver of the channel, + * does not compensate for stacking. * * No encoding conversions are applied to the bytes being read. * @@ -3676,15 +2856,14 @@ Tcl_Write( */ int -Tcl_WriteRaw( - Tcl_Channel chan, /* The channel to buffer output for. */ - const char *src, /* Data to queue in output buffer. */ - int srcLen) /* Length of data in bytes, or < 0 for - * strlen(). */ +Tcl_WriteRaw(chan, src, srcLen) + Tcl_Channel chan; /* The channel to buffer output for. */ + CONST char *src; /* Data to queue in output buffer. */ + int srcLen; /* Length of data in bytes, or < 0 for + * strlen(). */ { Channel *chanPtr = ((Channel *) chan); - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ int errorCode, written; if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) { @@ -3692,7 +2871,7 @@ Tcl_WriteRaw( } if (srcLen < 0) { - srcLen = strlen(src); + srcLen = strlen(src); } /* @@ -3700,7 +2879,9 @@ Tcl_WriteRaw( * The code was stolen from 'FlushChannel'. */ - written = ChanWrite(chanPtr, src, srcLen, &errorCode); + written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData, + src, srcLen, &errorCode); + if (written < 0) { Tcl_SetErrno(errorCode); } @@ -3714,11 +2895,11 @@ Tcl_WriteRaw( * Tcl_WriteChars -- * * Takes a sequence of UTF-8 characters and converts them for output - * using the channel's current encoding, may queue the buffer for output - * if it gets full, and also remembers whether the current buffer is - * ready e.g. if it contains a newline and we are in line buffering - * mode. Compensates stacking, i.e. will redirect the data from the - * specified channel to the topmost channel in a stack. + * using the channel's current encoding, may queue the buffer for + * output if it gets full, and also remembers whether the current + * buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. Compensates stacking, i.e. will redirect the + * data from the specified channel to the topmost channel in a stack. * * Results: * The number of bytes written or -1 in case of error. If -1, @@ -3732,14 +2913,13 @@ Tcl_WriteRaw( */ int -Tcl_WriteChars( - Tcl_Channel chan, /* The channel to buffer output for. */ - const char *src, /* UTF-8 characters to queue in output - * buffer. */ - int len) /* Length of string in bytes, or < 0 for +Tcl_WriteChars(chan, src, len) + Tcl_Channel chan; /* The channel to buffer output for. */ + CONST char *src; /* UTF-8 characters to queue in output buffer. */ + int len; /* Length of string in bytes, or < 0 for * strlen(). */ { - ChannelState *statePtr; /* State info for channel */ + ChannelState *statePtr; /* state info for channel */ statePtr = ((Channel *) chan)->state; @@ -3747,7 +2927,7 @@ Tcl_WriteChars( return -1; } - return DoWriteChars((Channel *) chan, src, len); + return DoWriteChars ((Channel*) chan, src, len); } /* @@ -3756,11 +2936,11 @@ Tcl_WriteChars( * DoWriteChars -- * * Takes a sequence of UTF-8 characters and converts them for output - * using the channel's current encoding, may queue the buffer for output - * if it gets full, and also remembers whether the current buffer is - * ready e.g. if it contains a newline and we are in line buffering mode. - * Compensates stacking, i.e. will redirect the data from the specified - * channel to the topmost channel in a stack. + * using the channel's current encoding, may queue the buffer for + * output if it gets full, and also remembers whether the current + * buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. Compensates stacking, i.e. will redirect the + * data from the specified channel to the topmost channel in a stack. * * Results: * The number of bytes written or -1 in case of error. If -1, @@ -3774,44 +2954,36 @@ Tcl_WriteChars( */ static int -DoWriteChars( - 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 +DoWriteChars(chanPtr, src, len) + 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(). */ { /* * Always use the topmost channel of the stack */ - - ChannelState *statePtr; /* State info for channel */ + 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) { /* - * Inefficient way to convert UTF-8 to byte-array, but the code - * parallels the way it is done for objects. - * Special case for 1-byte (used by eg [puts] for the \n) could - * be extended to more efficient translation of the src string. + * Inefficient way to convert UTF-8 to byte-array, but the + * code parallels the way it is done for objects. */ + Tcl_Obj *objPtr; int result; - if ((len == 1) && (UCHAR(*src) < 0xC0)) { - result = WriteBytes(chanPtr, src, len); - } else { - Tcl_Obj *objPtr = Tcl_NewStringObj(src, len); - - src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len); - result = WriteBytes(chanPtr, src, len); - TclDecrRefCount(objPtr); - } + objPtr = Tcl_NewStringObj(src, len); + src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len); + result = WriteBytes(chanPtr, src, len); + Tcl_DecrRefCount(objPtr); return result; } return WriteChars(chanPtr, src, len); @@ -3822,17 +2994,17 @@ DoWriteChars( * * Tcl_WriteObj -- * - * Takes the Tcl object and queues its contents for output. If the - * encoding of the channel is NULL, takes the byte-array representation - * of the object and queues those bytes for output. Otherwise, takes the - * characters in the UTF-8 (string) representation of the object and - * converts them for output using the channel's current encoding. May - * flush internal buffers to output if one becomes full or is ready for - * some other reason, e.g. if it contains a newline and the channel is in - * line buffering mode. + * Takes the Tcl object and queues its contents for output. If the + * encoding of the channel is NULL, takes the byte-array representation + * of the object and queues those bytes for output. Otherwise, takes + * the characters in the UTF-8 (string) representation of the object + * and converts them for output using the channel's current encoding. + * May flush internal buffers to output if one becomes full or is ready + * for some other reason, e.g. if it contains a newline and the channel + * is in line buffering mode. * * Results: - * The number of bytes written or -1 in case of error. If -1, + * The number of bytes written or -1 in case of error. If -1, * Tcl_GetErrno() will return the error code. * * Side effects: @@ -3843,21 +3015,20 @@ DoWriteChars( */ int -Tcl_WriteObj( - Tcl_Channel chan, /* The channel to buffer output for. */ - Tcl_Obj *objPtr) /* The object to write. */ +Tcl_WriteObj(chan, objPtr) + Tcl_Channel chan; /* The channel to buffer output for. */ + Tcl_Obj *objPtr; /* The object to write. */ { /* * Always use the topmost channel of the stack */ - Channel *chanPtr; - ChannelState *statePtr; /* State info for channel */ - const char *src; + ChannelState *statePtr; /* state info for channel */ + char *src; int srcLen; statePtr = ((Channel *) chan)->state; - chanPtr = statePtr->topChanPtr; + chanPtr = statePtr->topChanPtr; if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { return -1; @@ -3866,52 +3037,20 @@ Tcl_WriteObj( src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen); return WriteBytes(chanPtr, src, srcLen); } else { - src = TclGetStringFromObj(objPtr, &srcLen); + src = Tcl_GetStringFromObj(objPtr, &srcLen); return WriteChars(chanPtr, src, srcLen); } } -static void -WillWrite( - Channel *chanPtr) -{ - int inputBuffered; - - if ((chanPtr->typePtr->seekProc != NULL) && - ((inputBuffered = Tcl_InputBuffered((Tcl_Channel) chanPtr)) > 0)){ - int ignore; - - DiscardInputQueued(chanPtr->state, 0); - ChanSeek(chanPtr, -inputBuffered, SEEK_CUR, &ignore); - } -} - -static int -WillRead( - Channel *chanPtr) -{ - if ((chanPtr->typePtr->seekProc != NULL) - && (Tcl_OutputBuffered((Tcl_Channel) chanPtr) > 0)) { - if ((chanPtr->state->curOutPtr != NULL) - && IsBufferReady(chanPtr->state->curOutPtr)) { - SetFlag(chanPtr->state, BUFFER_READY); - } - if (FlushChannel(NULL, chanPtr, 0) != 0) { - return -1; - } - } - return 0; -} - /* *---------------------------------------------------------------------- * * WriteBytes -- * - * Write a sequence of bytes into an output buffer, may queue the buffer - * for output if it gets full, and also remembers whether the current - * buffer is ready e.g. if it contains a newline and we are in line - * buffering mode. + * Write a sequence of bytes into an output buffer, may queue the + * buffer for output if it gets full, and also remembers whether the + * current buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. * * Results: * The number of bytes written or -1 in case of error. If -1, @@ -3925,40 +3064,33 @@ WillRead( */ static int -WriteBytes( - Channel *chanPtr, /* The channel to buffer output for. */ - const char *src, /* Bytes to write. */ - int srcLen) /* Number of bytes to write. */ +WriteBytes(chanPtr, src, srcLen) + Channel *chanPtr; /* The channel to buffer output for. */ + CONST char *src; /* Bytes to write. */ + int srcLen; /* Number of bytes to write. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; char *dst; - int dstMax, sawLF, savedLF, total, dstLen, toWrite, translate; - - if (srcLen) { - WillWrite(chanPtr); - } - + int dstMax, sawLF, savedLF, total, dstLen, toWrite; + total = 0; sawLF = 0; savedLF = 0; - translate = GotFlag(statePtr, CHANNEL_LINEBUFFERED) - || (statePtr->outputTranslation != TCL_TRANSLATE_LF); /* - * Loop over all bytes in src, storing them in output buffer with proper - * EOL translation. + * Loop over all bytes in src, storing them in output buffer with + * proper EOL translation. */ while (srcLen + savedLF > 0) { bufPtr = statePtr->curOutPtr; if (bufPtr == NULL) { bufPtr = AllocChannelBuffer(statePtr->bufSize); - statePtr->curOutPtr = bufPtr; + statePtr->curOutPtr = bufPtr; } - dst = InsertPoint(bufPtr); - dstMax = SpaceLeft(bufPtr); + dst = bufPtr->buf + bufPtr->nextAdded; + dstMax = bufPtr->bufLength - bufPtr->nextAdded; dstLen = dstMax; toWrite = dstLen; @@ -3966,32 +3098,25 @@ WriteBytes( toWrite = srcLen; } - if (translate) { - if (savedLF) { - /* - * A '\n' was left over from last call to TranslateOutputEOL() - * and we need to store it in this buffer. If the channel is - * line-based, we will need to flush it. - */ + if (savedLF) { + /* + * A '\n' was left over from last call to TranslateOutputEOL() + * and we need to store it in this buffer. If the channel is + * line-based, we will need to flush it. + */ - *dst++ = '\n'; - dstLen--; - sawLF++; - } - if (TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite)) { - sawLF++; - } - dstLen += savedLF; - savedLF = 0; - if (dstLen > dstMax) { - savedLF = 1; - dstLen = dstMax; - } - } else { - memcpy(dst, src, toWrite); - dstLen = toWrite; + *dst++ = '\n'; + dstLen--; + sawLF++; } + sawLF += TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite); + dstLen += savedLF; + savedLF = 0; + if (dstLen > dstMax) { + savedLF = 1; + dstLen = dstMax; + } bufPtr->nextAdded += dstLen; if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) { return -1; @@ -4009,10 +3134,11 @@ WriteBytes( * * WriteChars -- * - * Convert UTF-8 bytes to the channel's external encoding and write the - * produced bytes into an output buffer, may queue the buffer for output - * if it gets full, and also remembers whether the current buffer is - * ready e.g. if it contains a newline and we are in line buffering mode. + * Convert UTF-8 bytes to the channel's external encoding and + * write the produced bytes into an output buffer, may queue the + * buffer for output if it gets full, and also remembers whether the + * current buffer is ready e.g. if it contains a newline and we are in + * line buffering mode. * * Results: * The number of bytes written or -1 in case of error. If -1, @@ -4026,25 +3152,20 @@ WriteBytes( */ static int -WriteChars( - Channel *chanPtr, /* The channel to buffer output for. */ - const char *src, /* UTF-8 string to write. */ - int srcLen) /* Length of UTF-8 string in bytes. */ +WriteChars(chanPtr, src, srcLen) + Channel *chanPtr; /* The channel to buffer output for. */ + CONST char *src; /* UTF-8 string to write. */ + int srcLen; /* Length of UTF-8 string in bytes. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; char *dst, *stage; int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote; int stageLen, toWrite, stageRead, endEncoding, result; - int consumedSomething, translate; + int consumedSomething; Tcl_Encoding encoding; char safe[BUFFER_PADDING]; - - if (srcLen) { - WillWrite(chanPtr); - } - + total = 0; sawLF = 0; savedLF = 0; @@ -4057,9 +3178,6 @@ WriteChars( endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0); - translate = GotFlag(statePtr, CHANNEL_LINEBUFFERED) - || (statePtr->outputTranslation != TCL_TRANSLATE_LF); - /* * Loop over all UTF-8 characters in src, storing them in staging buffer * with proper EOL translation. @@ -4067,7 +3185,7 @@ WriteChars( consumedSomething = 1; while (consumedSomething && (srcLen + savedLF + endEncoding > 0)) { - consumedSomething = 0; + consumedSomething = 0; stage = statePtr->outputStage; stageMax = statePtr->bufSize; stageLen = stageMax; @@ -4077,35 +3195,27 @@ WriteChars( toWrite = srcLen; } - if (translate) { - if (savedLF) { - /* - * A '\n' was left over from last call to TranslateOutputEOL() - * and we need to store it in the staging buffer. If the - * channel is line-based, we will need to flush the output - * buffer (after translating the staging buffer). - */ - - *stage++ = '\n'; - stageLen--; - sawLF++; - } - if (TranslateOutputEOL(statePtr, stage, src, &stageLen, - &toWrite)) { - sawLF++; - } + if (savedLF) { + /* + * A '\n' was left over from last call to TranslateOutputEOL() + * and we need to store it in the staging buffer. If the + * channel is line-based, we will need to flush the output + * buffer (after translating the staging buffer). + */ + + *stage++ = '\n'; + stageLen--; + sawLF++; + } + sawLF += TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite); - stage -= savedLF; - stageLen += savedLF; - savedLF = 0; + stage -= savedLF; + stageLen += savedLF; + savedLF = 0; - if (stageLen > stageMax) { - savedLF = 1; - stageLen = stageMax; - } - } else { - memcpy(stage, src, toWrite); - stageLen = toWrite; + if (stageLen > stageMax) { + savedLF = 1; + stageLen = stageMax; } src += toWrite; srcLen -= toWrite; @@ -4121,16 +3231,17 @@ WriteChars( bufPtr = AllocChannelBuffer(statePtr->bufSize); statePtr->curOutPtr = bufPtr; } - dst = InsertPoint(bufPtr); - dstLen = SpaceLeft(bufPtr); + dst = bufPtr->buf + bufPtr->nextAdded; + dstLen = bufPtr->bufLength - bufPtr->nextAdded; if (saved != 0) { /* - * Here's some translated bytes left over from the last buffer - * that we need to stick at the beginning of this buffer. + * Here's some translated bytes left over from the last + * buffer that we need to stick at the beginning of this + * buffer. */ - - memcpy(dst, safe, (size_t) saved); + + memcpy((VOID *) dst, (VOID *) safe, (size_t) saved); bufPtr->nextAdded += saved; dst += saved; dstLen -= saved; @@ -4142,8 +3253,7 @@ WriteChars( &statePtr->outputEncodingState, dst, dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL); - /* - * Fix for SF #506297, reported by Martin Forssen + /* Fix for SF #506297, reported by Martin Forssen * <ruric@users.sourceforge.net>. * * The encoding chosen in the script exposing the bug writes out @@ -4159,15 +3269,13 @@ WriteChars( */ statePtr->outputEncodingFlags &= ~TCL_ENCODING_START; - /* * The following code must be executed only when result is not 0. */ - - if ((result != 0) && (stageRead + dstWrote == 0)) { + if (result && ((stageRead + dstWrote) == 0)) { /* * We have an incomplete UTF-8 character at the end of the - * staging buffer. It will get moved to the beginning of the + * staging buffer. It will get moved to the beginning of the * staging buffer followed by more bytes from src. */ @@ -4178,17 +3286,18 @@ WriteChars( break; } bufPtr->nextAdded += dstWrote; - if (IsBufferOverflowing(bufPtr)) { + if (bufPtr->nextAdded > bufPtr->bufLength) { /* * When translating from UTF-8 to external encoding, we - * allowed the translation to produce a character that crossed - * the end of the output buffer, so that we would get a - * completely full buffer before flushing it. The extra bytes - * will be moved to the beginning of the next buffer. + * allowed the translation to produce a character that + * crossed the end of the output buffer, so that we would + * get a completely full buffer before flushing it. The + * extra bytes will be moved to the beginning of the next + * buffer. */ - saved = -SpaceLeft(bufPtr); - memcpy(safe, dst + dstLen, (size_t) saved); + saved = bufPtr->nextAdded - bufPtr->bufLength; + memcpy((VOID *) safe, (VOID *) (dst + dstLen), (size_t) saved); bufPtr->nextAdded = bufPtr->bufLength; } if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) { @@ -4214,14 +3323,13 @@ WriteChars( } } - /* - * If nothing was written and it happened because there was no progress in - * the UTF conversion, we throw an error. + /* If nothing was written and it happened because there was no progress + * in the UTF conversion, we throw an error. */ if (!consumedSomething && (total == 0)) { - Tcl_SetErrno(EINVAL); - return -1; + Tcl_SetErrno (EINVAL); + return -1; } return total; } @@ -4231,120 +3339,125 @@ WriteChars( * * TranslateOutputEOL -- * - * Helper function for WriteBytes() and WriteChars(). Converts the '\n' - * characters in the source buffer into the appropriate EOL form - * specified by the output translation mode. + * Helper function for WriteBytes() and WriteChars(). Converts the + * '\n' characters in the source buffer into the appropriate EOL + * form specified by the output translation mode. * - * EOL translation stops either when the source buffer is empty or the - * output buffer is full. + * EOL translation stops either when the source buffer is empty + * or the output buffer is full. * - * When converting to CRLF mode and there is only 1 byte left in the - * output buffer, this routine stores the '\r' in the last byte and then - * stores the '\n' in the byte just past the end of the buffer. The - * caller is responsible for passing in a buffer that is large enough to - * hold the extra byte. + * When converting to CRLF mode and there is only 1 byte left in + * the output buffer, this routine stores the '\r' in the last + * byte and then stores the '\n' in the byte just past the end of the + * buffer. The caller is responsible for passing in a buffer that + * is large enough to hold the extra byte. * * Results: - * The return value is 1 if a '\n' was translated from the source buffer, - * or 0 otherwise -- this can be used by the caller to decide to flush a - * line-based channel even though the channel buffer is not full. + * The return value is 1 if a '\n' was translated from the source + * buffer, or 0 otherwise -- this can be used by the caller to + * decide to flush a line-based channel even though the channel + * buffer is not full. * - * *dstLenPtr is filled with how many bytes of the output buffer were - * used. As mentioned above, this can be one more that the output - * buffer's specified length if a CRLF was stored. + * *dstLenPtr is filled with how many bytes of the output buffer + * were used. As mentioned above, this can be one more that + * the output buffer's specified length if a CRLF was stored. * - * *srcLenPtr is filled with how many bytes of the source buffer were - * consumed. + * *srcLenPtr is filled with how many bytes of the source buffer + * were consumed. * * Side effects: - * It may be obvious, but bears mentioning that when converting in CRLF - * mode (which requires two bytes of storage in the output buffer), the - * number of bytes consumed from the source buffer will be less than the - * number of bytes stored in the output buffer. + * It may be obvious, but bears mentioning that when converting + * in CRLF mode (which requires two bytes of storage in the output + * buffer), the number of bytes consumed from the source buffer + * will be less than the number of bytes stored in the output buffer. * *--------------------------------------------------------------------------- */ static int -TranslateOutputEOL( - ChannelState *statePtr, /* Channel being read, for translation and +TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) + ChannelState *statePtr; /* Channel being read, for translation and * buffering modes. */ - char *dst, /* Output buffer filled with UTF-8 chars by + char *dst; /* Output buffer filled with UTF-8 chars by * applying appropriate EOL translation to * source characters. */ - const char *src, /* Source UTF-8 characters. */ - int *dstLenPtr, /* On entry, the maximum length of output - * buffer in bytes. On exit, the number of + CONST char *src; /* Source UTF-8 characters. */ + int *dstLenPtr; /* On entry, the maximum length of output + * buffer in bytes. On exit, the number of * bytes actually used in output buffer. */ - int *srcLenPtr) /* On entry, the length of source buffer. On - * exit, the number of bytes read from the - * source buffer. */ + int *srcLenPtr; /* On entry, the length of source buffer. + * On exit, the number of bytes read from + * the source buffer. */ { char *dstEnd; int srcLen, newlineFound; - + newlineFound = 0; srcLen = *srcLenPtr; switch (statePtr->outputTranslation) { - case TCL_TRANSLATE_LF: - for (dstEnd = dst + srcLen; dst < dstEnd; ) { - if (*src == '\n') { - newlineFound = 1; - } - *dst++ = *src++; - } - *dstLenPtr = srcLen; - break; - case TCL_TRANSLATE_CR: - for (dstEnd = dst + srcLen; dst < dstEnd;) { - if (*src == '\n') { - *dst++ = '\r'; - newlineFound = 1; - src++; - } else { + case TCL_TRANSLATE_LF: { + for (dstEnd = dst + srcLen; dst < dstEnd; ) { + if (*src == '\n') { + newlineFound = 1; + } *dst++ = *src++; } + *dstLenPtr = srcLen; + break; } - *dstLenPtr = srcLen; - break; - case TCL_TRANSLATE_CRLF: { - /* - * Since this causes the number of bytes to grow, we start off trying - * to put 'srcLen' bytes into the output buffer, but allow it to store - * more bytes, as long as there's still source bytes and room in the - * output buffer. - */ - - char *dstStart, *dstMax; - const char *srcStart; - - dstStart = dst; - dstMax = dst + *dstLenPtr; + case TCL_TRANSLATE_CR: { + for (dstEnd = dst + srcLen; dst < dstEnd;) { + if (*src == '\n') { + *dst++ = '\r'; + newlineFound = 1; + src++; + } else { + *dst++ = *src++; + } + } + *dstLenPtr = srcLen; + break; + } + case TCL_TRANSLATE_CRLF: { + /* + * Since this causes the number of bytes to grow, we + * start off trying to put 'srcLen' bytes into the + * output buffer, but allow it to store more bytes, as + * long as there's still source bytes and room in the + * output buffer. + */ - srcStart = src; + char *dstStart, *dstMax; + CONST char *srcStart; + + dstStart = dst; + dstMax = dst + *dstLenPtr; - if (srcLen < *dstLenPtr) { - dstEnd = dst + srcLen; - } else { - dstEnd = dst + *dstLenPtr; - } - while (dst < dstEnd) { - if (*src == '\n') { - if (dstEnd < dstMax) { - dstEnd++; + srcStart = src; + + if (srcLen < *dstLenPtr) { + dstEnd = dst + srcLen; + } else { + dstEnd = dst + *dstLenPtr; + } + while (dst < dstEnd) { + if (*src == '\n') { + if (dstEnd < dstMax) { + dstEnd++; + } + *dst++ = '\r'; + newlineFound = 1; } - *dst++ = '\r'; - newlineFound = 1; + *dst++ = *src++; } - *dst++ = *src++; + *srcLenPtr = src - srcStart; + *dstLenPtr = dst - dstStart; + break; + } + default: { + break; } - *srcLenPtr = src - srcStart; - *dstLenPtr = dst - dstStart; - break; - } - default: - break; } return newlineFound; } @@ -4354,12 +3467,12 @@ TranslateOutputEOL( * * CheckFlush -- * - * Helper function for WriteBytes() and WriteChars(). If the channel - * buffer is ready to be flushed, flush it. + * Helper function for WriteBytes() and WriteChars(). If the + * channel buffer is ready to be flushed, flush it. * * Results: - * The return value is -1 if there was a problem flushing the channel - * buffer, or 0 otherwise. + * The return value is -1 if there was a problem flushing the + * channel buffer, or 0 otherwise. * * Side effects: * The buffer will be recycled if it is flushed. @@ -4368,15 +3481,13 @@ TranslateOutputEOL( */ static int -CheckFlush( - Channel *chanPtr, /* Channel being read, for buffering mode. */ - ChannelBuffer *bufPtr, /* Channel buffer to possibly flush. */ - int newlineFlag) /* Non-zero if a the channel buffer contains a - * newline. */ +CheckFlush(chanPtr, bufPtr, newlineFlag) + Channel *chanPtr; /* Channel being read, for buffering mode. */ + ChannelBuffer *bufPtr; /* Channel buffer to possibly flush. */ + int newlineFlag; /* Non-zero if a the channel buffer + * contains a newline. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - + ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* * The current buffer is ready for output: * 1. if it is full. @@ -4384,18 +3495,18 @@ CheckFlush( * 3. if it contains any output and this channel is unbuffered. */ - if (!GotFlag(statePtr, BUFFER_READY)) { - if (IsBufferFull(bufPtr)) { - SetFlag(statePtr, BUFFER_READY); - } else if (GotFlag(statePtr, CHANNEL_LINEBUFFERED)) { + if ((statePtr->flags & BUFFER_READY) == 0) { + if (bufPtr->nextAdded == bufPtr->bufLength) { + statePtr->flags |= BUFFER_READY; + } else if (statePtr->flags & CHANNEL_LINEBUFFERED) { if (newlineFlag != 0) { - SetFlag(statePtr, BUFFER_READY); + statePtr->flags |= BUFFER_READY; } - } else if (GotFlag(statePtr, CHANNEL_UNBUFFERED)) { - SetFlag(statePtr, BUFFER_READY); + } else if (statePtr->flags & CHANNEL_UNBUFFERED) { + statePtr->flags |= BUFFER_READY; } } - if (GotFlag(statePtr, BUFFER_READY)) { + if (statePtr->flags & BUFFER_READY) { if (FlushChannel(NULL, chanPtr, 0) != 0) { return -1; } @@ -4416,31 +3527,31 @@ CheckFlush( * error or condition that occurred. * * Side effects: - * May flush output on the channel. May cause input to be consumed from - * the channel. + * May flush output on the channel. May cause input to be consumed + * from the channel. * *--------------------------------------------------------------------------- */ int -Tcl_Gets( - Tcl_Channel chan, /* Channel from which to read. */ - Tcl_DString *lineRead) /* The line read will be appended to this - * DString as UTF-8 characters. The caller +Tcl_Gets(chan, lineRead) + Tcl_Channel chan; /* Channel from which to read. */ + Tcl_DString *lineRead; /* The line read will be appended to this + * DString as UTF-8 characters. The caller * must have initialized it and is responsible * for managing the storage. */ { Tcl_Obj *objPtr; int charsStored, length; - const char *string; + char *string; - TclNewObj(objPtr); + objPtr = Tcl_NewObj(); charsStored = Tcl_GetsObj(chan, objPtr); if (charsStored > 0) { - string = TclGetStringFromObj(objPtr, &length); + string = Tcl_GetStringFromObj(objPtr, &length); Tcl_DStringAppend(lineRead, string, length); } - TclDecrRefCount(objPtr); + Tcl_DecrRefCount(objPtr); return charsStored; } @@ -4450,71 +3561,60 @@ Tcl_Gets( * Tcl_GetsObj -- * * Accumulate input from the input channel until end-of-line or - * end-of-file has been seen. Bytes read from the input channel are - * converted to UTF-8 using the encoding specified by the channel. + * end-of-file has been seen. Bytes read from the input channel + * are converted to UTF-8 using the encoding specified by the + * channel. * * Results: * Number of characters accumulated in the object or -1 if error, - * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error - * code for the error or condition that occurred. + * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the + * POSIX error code for the error or condition that occurred. * * Side effects: * Consumes input from the channel. * - * On reading EOF, leave channel pointing at EOF char. On reading EOL, - * leave channel pointing after EOL, but don't return EOL in dst buffer. + * On reading EOF, leave channel pointing at EOF char. + * On reading EOL, leave channel pointing after EOL, but don't + * return EOL in dst buffer. * *--------------------------------------------------------------------------- */ int -Tcl_GetsObj( - Tcl_Channel chan, /* Channel from which to read. */ - Tcl_Obj *objPtr) /* The line read will be appended to this +Tcl_GetsObj(chan, objPtr) + Tcl_Channel chan; /* Channel from which to read. */ + Tcl_Obj *objPtr; /* The line read will be appended to this * object as UTF-8 characters. */ { GetsState gs; Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved; Tcl_Encoding encoding; char *dst, *dstEnd, *eol, *eof; Tcl_EncodingState oldState; - if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { - copiedTotal = -1; - goto done; - } - - /* - * A binary version of Tcl_GetsObj. This could also handle encodings that - * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion - * done on objPtr. - */ - - if ((statePtr->encoding == NULL) - && ((statePtr->inputTranslation == TCL_TRANSLATE_LF) - || (statePtr->inputTranslation == TCL_TRANSLATE_CR))) { - return TclGetsObjBinary(chan, objPtr); - } - /* * This operation should occur at the top of a channel stack. */ chanPtr = statePtr->topChanPtr; + if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { + copiedTotal = -1; + goto done; + } + bufPtr = statePtr->inQueueHead; encoding = statePtr->encoding; /* - * Preserved so we can restore the channel's state in case we don't find a - * newline in the available input. + * Preserved so we can restore the channel's state in case we don't + * find a newline in the available input. */ - TclGetStringFromObj(objPtr, &oldLength); + Tcl_GetStringFromObj(objPtr, &oldLength); oldFlags = statePtr->inputEncodingFlags; oldState = statePtr->inputEncodingState; oldRemoved = BUFFER_PADDING; @@ -4524,25 +3624,17 @@ Tcl_GetsObj( /* * If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't - * produce ByteArray objects. + * produce ByteArray objects. To avoid circularity problems, + * "iso8859-1" is builtin to Tcl. */ if (encoding == NULL) { - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - - if (tsdPtr->binaryEncoding == NULL) { - tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1"); - Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL); - } - encoding = tsdPtr->binaryEncoding; - if (encoding == NULL) { - Tcl_Panic("attempted gets on binary channel where no iso8859-1 encoding available"); - } + encoding = Tcl_GetEncoding(NULL, "iso8859-1"); } /* - * Object used by FilterInputBytes to keep track of how much data has been - * consumed from the channel buffers. + * Object used by FilterInputBytes to keep track of how much data has + * been consumed from the channel buffers. */ gs.objPtr = objPtr; @@ -4569,10 +3661,10 @@ Tcl_GetsObj( } dstEnd = dst + gs.bytesWrote; } - + /* - * Remember if EOF char is seen, then look for EOL anyhow, because the - * EOL might be before the EOF char. + * Remember if EOF char is seen, then look for EOL anyhow, because + * the EOL might be before the EOF char. */ if (inEofChar != '\0') { @@ -4591,37 +3683,31 @@ Tcl_GetsObj( */ switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\n') { - skip = 1; - goto gotEOL; + case TCL_TRANSLATE_LF: { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\n') { + skip = 1; + goto goteol; + } } + break; } - break; - case TCL_TRANSLATE_CR: - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\r') { - skip = 1; - goto gotEOL; + case TCL_TRANSLATE_CR: { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + skip = 1; + goto goteol; + } } + break; } - break; - case TCL_TRANSLATE_CRLF: - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\r') { - eol++; - - /* - * If a CR is at the end of the buffer, then check for a - * LF at the begining of the next buffer, unless EOF char - * was found already. - */ - - if (eol >= dstEnd) { - int offset; - - if (eol != eof) { + case TCL_TRANSLATE_CRLF: { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + eol++; + if (eol >= dstEnd) { + int offset; + offset = eol - objPtr->bytes; dst = dstEnd; if (FilterInputBytes(chanPtr, &gs) != 0) { @@ -4629,92 +3715,91 @@ Tcl_GetsObj( } dstEnd = dst + gs.bytesWrote; eol = objPtr->bytes + offset; + if (eol >= dstEnd) { + skip = 0; + goto goteol; + } } - if (eol >= dstEnd) { - skip = 0; - goto gotEOL; + if (*eol == '\n') { + eol--; + skip = 2; + goto goteol; } } - if (*eol == '\n') { - eol--; - skip = 2; - goto gotEOL; - } - } - } - break; - case TCL_TRANSLATE_AUTO: - eol = dst; - skip = 1; - if (GotFlag(statePtr, INPUT_SAW_CR)) { - ResetFlag(statePtr, INPUT_SAW_CR); - if ((eol < dstEnd) && (*eol == '\n')) { - /* - * Skip the raw bytes that make up the '\n'. - */ - - char tmp[1 + TCL_UTF_MAX]; - int rawRead; - - bufPtr = gs.bufPtr; - Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), - gs.rawRead, statePtr->inputEncodingFlags, - &gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead, NULL, - NULL); - bufPtr->nextRemoved += rawRead; - gs.rawRead -= rawRead; - gs.bytesWrote--; - gs.charsWrote--; - memmove(dst, dst + 1, (size_t) (dstEnd - dst)); - dstEnd--; } + break; } - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\r') { - eol++; - if (eol == dstEnd) { + case TCL_TRANSLATE_AUTO: { + eol = dst; + skip = 1; + if (statePtr->flags & INPUT_SAW_CR) { + statePtr->flags &= ~INPUT_SAW_CR; + if (*eol == '\n') { /* - * If buffer ended on \r, peek ahead to see if a \n is - * available, unless EOF char was found already. + * Skip the raw bytes that make up the '\n'. */ - if (eol != eof) { - int offset; + char tmp[1 + TCL_UTF_MAX]; + int rawRead; + + bufPtr = gs.bufPtr; + Tcl_ExternalToUtf(NULL, gs.encoding, + bufPtr->buf + bufPtr->nextRemoved, + gs.rawRead, statePtr->inputEncodingFlags, + &gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead, + NULL, NULL); + bufPtr->nextRemoved += rawRead; + gs.rawRead -= rawRead; + gs.bytesWrote--; + gs.charsWrote--; + memmove(dst, dst + 1, (size_t) (dstEnd - dst)); + dstEnd--; + } + } + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + eol++; + if (eol == dstEnd) { + /* + * If buffer ended on \r, peek ahead to see if a + * \n is available. + */ + int offset; + offset = eol - objPtr->bytes; dst = dstEnd; PeekAhead(chanPtr, &dstEnd, &gs); eol = objPtr->bytes + offset; + if (eol >= dstEnd) { + eol--; + statePtr->flags |= INPUT_SAW_CR; + goto goteol; + } } - - if (eol >= dstEnd) { - eol--; - SetFlag(statePtr, INPUT_SAW_CR); - goto gotEOL; + if (*eol == '\n') { + skip++; } + eol--; + goto goteol; + } else if (*eol == '\n') { + goto goteol; } - if (*eol == '\n') { - skip++; - } - eol--; - goto gotEOL; - } else if (*eol == '\n') { - goto gotEOL; } } } if (eof != NULL) { /* - * EOF character was seen. On EOF, leave current file position + * EOF character was seen. On EOF, leave current file position * pointing at the EOF character, but don't store the EOF * character in the output string. */ dstEnd = eof; - SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); statePtr->inputEncodingFlags |= TCL_ENCODING_END; } - if (GotFlag(statePtr, CHANNEL_EOF)) { + if (statePtr->flags & CHANNEL_EOF) { skip = 0; eol = dstEnd; if (eol == objPtr->bytes + oldLength) { @@ -4724,38 +3809,29 @@ Tcl_GetsObj( */ Tcl_SetObjLength(objPtr, oldLength); - CommonGetsCleanup(chanPtr); + CommonGetsCleanup(chanPtr, encoding); copiedTotal = -1; goto done; } - goto gotEOL; + goto goteol; } dst = dstEnd; } /* - * Found EOL or EOF, but the output buffer may now contain too many UTF-8 - * characters. We need to know how many raw bytes correspond to the number - * of UTF-8 characters we want, plus how many raw bytes correspond to the - * character(s) making up EOL (if any), so we can remove the correct - * number of bytes from the channel buffer. - */ - - gotEOL: - /* - * Regenerate the top channel, in case it was changed due to - * self-modifying reflected transforms. + * Found EOL or EOF, but the output buffer may now contain too many + * UTF-8 characters. We need to know how many raw bytes correspond to + * the number of UTF-8 characters we want, plus how many raw bytes + * correspond to the character(s) making up EOL (if any), so we can + * remove the correct number of bytes from the channel buffer. */ - - chanPtr = statePtr->topChanPtr; - + + goteol: bufPtr = gs.bufPtr; - if (bufPtr == NULL) { - Tcl_Panic("Tcl_GetsObj: gotEOL reached with bufPtr==NULL"); - } statePtr->inputEncodingState = gs.state; - Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), gs.rawRead, - statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst, + Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved, + gs.rawRead, statePtr->inputEncodingFlags, + &statePtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX, &gs.rawRead, NULL, &gs.charsWrote); bufPtr->nextRemoved += gs.rawRead; @@ -4765,35 +3841,25 @@ Tcl_GetsObj( */ Tcl_SetObjLength(objPtr, eol - objPtr->bytes); - CommonGetsCleanup(chanPtr); - ResetFlag(statePtr, CHANNEL_BLOCKED); + CommonGetsCleanup(chanPtr, encoding); + statePtr->flags &= ~CHANNEL_BLOCKED; copiedTotal = gs.totalChars + gs.charsWrote - skip; goto done; /* - * Couldn't get a complete line. This only happens if we get a error - * reading from the channel or we are non-blocking and there wasn't an EOL - * or EOF in the data available. - */ - - restore: - /* - * Regenerate the top channel, in case it was changed due to - * self-modifying reflected transforms. + * Couldn't get a complete line. This only happens if we get a error + * reading from the channel or we are non-blocking and there wasn't + * an EOL or EOF in the data available. */ - chanPtr = statePtr->topChanPtr; - + restore: bufPtr = statePtr->inQueueHead; - if (bufPtr == NULL) { - Tcl_Panic("Tcl_GetsObj: restore reached with bufPtr==NULL"); - } bufPtr->nextRemoved = oldRemoved; for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) { bufPtr->nextRemoved = BUFFER_PADDING; } - CommonGetsCleanup(chanPtr); + CommonGetsCleanup(chanPtr, encoding); statePtr->inputEncodingState = oldState; statePtr->inputEncodingFlags = oldFlags; @@ -4801,347 +3867,66 @@ Tcl_GetsObj( /* * We didn't get a complete line so we need to indicate to UpdateInterest - * that the gets blocked. It will wait for more data instead of firing a - * timer, avoiding a busy wait. This is where we are assuming that the - * next operation is a gets. No more file events will be delivered on this - * channel until new data arrives or some operation is performed on the - * channel (e.g. gets, read, fconfigure) that changes the blocking state. - * Note that this means a file event will not be delivered even though a - * read would be able to consume the buffered data. + * that the gets blocked. It will wait for more data instead of firing + * a timer, avoiding a busy wait. This is where we are assuming that the + * next operation is a gets. No more file events will be delivered on + * this channel until new data arrives or some operation is performed + * on the channel (e.g. gets, read, fconfigure) that changes the blocking + * state. Note that this means a file event will not be delivered even + * though a read would be able to consume the buffered data. */ - SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + statePtr->flags |= CHANNEL_NEED_MORE_DATA; copiedTotal = -1; + done: /* - * Update the notifier state so we don't block while there is still data - * in the buffers. + * Update the notifier state so we don't block while there is still + * data in the buffers. */ - done: - /* - * Regenerate the top channel, in case it was changed due to - * self-modifying reflected transforms. - */ - - chanPtr = statePtr->topChanPtr; - UpdateInterest(chanPtr); return copiedTotal; } - -/* - *--------------------------------------------------------------------------- - * - * TclGetsObjBinary -- - * - * A variation of Tcl_GetsObj that works directly on the buffers until - * end-of-line or end-of-file has been seen. Bytes read from the input - * channel return as a ByteArray obj. - * - * Results: - * Number of characters accumulated in the object or -1 if error, - * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error - * code for the error or condition that occurred. - * - * Side effects: - * Consumes input from the channel. - * - * On reading EOF, leave channel pointing at EOF char. On reading EOL, - * leave channel pointing after EOL, but don't return EOL in dst buffer. - * - *--------------------------------------------------------------------------- - */ - -static int -TclGetsObjBinary( - Tcl_Channel chan, /* Channel from which to read. */ - Tcl_Obj *objPtr) /* The line read will be appended to this - * object as UTF-8 characters. */ -{ - Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - ChannelBuffer *bufPtr; - int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved; - int rawLen, byteLen, eolChar; - unsigned char *dst, *dstEnd, *eol, *eof, *byteArray; - - /* - * This operation should occur at the top of a channel stack. - */ - - chanPtr = statePtr->topChanPtr; - - bufPtr = statePtr->inQueueHead; - - /* - * Preserved so we can restore the channel's state in case we don't find a - * newline in the available input. - */ - - byteArray = Tcl_GetByteArrayFromObj(objPtr, &byteLen); - oldFlags = statePtr->inputEncodingFlags; - oldRemoved = BUFFER_PADDING; - oldLength = byteLen; - if (bufPtr != NULL) { - oldRemoved = bufPtr->nextRemoved; - } - - rawLen = 0; - skip = 0; - eof = NULL; - inEofChar = statePtr->inEofChar; - /* - * Only handle TCL_TRANSLATE_LF and TCL_TRANSLATE_CR. - */ - - eolChar = (statePtr->inputTranslation == TCL_TRANSLATE_LF) ? '\n' : '\r'; - - while (1) { - /* - * Subtract the number of bytes that were removed from channel - * buffer during last call. - */ - - if (bufPtr != NULL) { - bufPtr->nextRemoved += rawLen; - if (!IsBufferReady(bufPtr)) { - bufPtr = bufPtr->nextPtr; - } - } - - if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) { - /* - * All channel buffers were exhausted and the caller still - * hasn't seen EOL. Need to read more bytes from the channel - * device. Side effect is to allocate another channel buffer. - */ - - if (GotFlag(statePtr, CHANNEL_BLOCKED)) { - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { - goto restore; - } - ResetFlag(statePtr, CHANNEL_BLOCKED); - } - if (GetInput(chanPtr) != 0) { - goto restore; - } - bufPtr = statePtr->inQueueTail; - } - - dst = (unsigned char *) RemovePoint(bufPtr); - dstEnd = dst + BytesLeft(bufPtr); - - /* - * Remember if EOF char is seen, then look for EOL anyhow, because the - * EOL might be before the EOF char. - * XXX - in the binary case, consider coincident search for eol/eof. - */ - - if (inEofChar != '\0') { - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == inEofChar) { - dstEnd = eol; - eof = eol; - break; - } - } - } - - /* - * On EOL, leave current file position pointing after the EOL, but - * don't store the EOL in the output string. - */ - - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == eolChar) { - skip = 1; - goto gotEOL; - } - } - if (eof != NULL) { - /* - * EOF character was seen. On EOF, leave current file position - * pointing at the EOF character, but don't store the EOF - * character in the output string. - */ - - SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); - statePtr->inputEncodingFlags |= TCL_ENCODING_END; - } - if (GotFlag(statePtr, CHANNEL_EOF)) { - skip = 0; - eol = dstEnd; - if ((dst == dstEnd) && (byteLen == oldLength)) { - /* - * If we didn't append any bytes before encountering EOF, - * caller needs to see -1. - */ - - byteArray = Tcl_SetByteArrayLength(objPtr, oldLength); - CommonGetsCleanup(chanPtr); - copiedTotal = -1; - goto done; - } - goto gotEOL; - } - - /* - * Copy bytes from the channel buffer to the ByteArray. - * This may realloc space, so keep track of result. - */ - - rawLen = dstEnd - dst; - byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen); - memcpy(byteArray + byteLen, dst, (size_t) rawLen); - byteLen += rawLen; - } - - /* - * Found EOL or EOF, but the output buffer may now contain too many bytes. - * We need to know how many bytes correspond to the number we want, so we - * can remove the correct number of bytes from the channel buffer. - */ - - gotEOL: - if (bufPtr == NULL) { - Tcl_Panic("TclGetsObjBinary: gotEOL reached with bufPtr==NULL"); - } - - rawLen = eol - dst; - byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen); - memcpy(byteArray + byteLen, dst, (size_t) rawLen); - byteLen += rawLen; - bufPtr->nextRemoved += rawLen + skip; - - /* - * Convert the buffer if there was an encoding. - * XXX - unimplemented. - */ - - if (statePtr->encoding != NULL) { - } - - /* - * Recycle all the emptied buffers. - */ - - CommonGetsCleanup(chanPtr); - ResetFlag(statePtr, CHANNEL_BLOCKED); - copiedTotal = byteLen; - goto done; - - /* - * Couldn't get a complete line. This only happens if we get a error - * reading from the channel or we are non-blocking and there wasn't an EOL - * or EOF in the data available. - */ - - restore: - bufPtr = statePtr->inQueueHead; - if (bufPtr == NULL) { - Tcl_Panic("TclGetsObjBinary: restore reached with bufPtr==NULL"); - } - bufPtr->nextRemoved = oldRemoved; - - for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) { - bufPtr->nextRemoved = BUFFER_PADDING; - } - CommonGetsCleanup(chanPtr); - - statePtr->inputEncodingFlags = oldFlags; - byteArray = Tcl_SetByteArrayLength(objPtr, oldLength); - - /* - * We didn't get a complete line so we need to indicate to UpdateInterest - * that the gets blocked. It will wait for more data instead of firing a - * timer, avoiding a busy wait. This is where we are assuming that the - * next operation is a gets. No more file events will be delivered on this - * channel until new data arrives or some operation is performed on the - * channel (e.g. gets, read, fconfigure) that changes the blocking state. - * Note that this means a file event will not be delivered even though a - * read would be able to consume the buffered data. - */ - - SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); - copiedTotal = -1; - - /* - * Update the notifier state so we don't block while there is still data - * in the buffers. - */ - - done: - UpdateInterest(chanPtr); - return copiedTotal; -} - -/* - *--------------------------------------------------------------------------- - * - * FreeBinaryEncoding -- - * - * Frees any "iso8859-1" Tcl_Encoding created by [gets] on a binary - * channel in a thread as part of that thread's finalization. - * - * Results: - * None. - * - *--------------------------------------------------------------------------- - */ - -static void -FreeBinaryEncoding( - ClientData dummy) /* Not used */ -{ - ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - - if (tsdPtr->binaryEncoding != NULL) { - Tcl_FreeEncoding(tsdPtr->binaryEncoding); - tsdPtr->binaryEncoding = NULL; - } -} - /* *--------------------------------------------------------------------------- * * FilterInputBytes -- * - * Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw - * bytes read from the channel. + * Helper function for Tcl_GetsObj. Produces UTF-8 characters from + * raw bytes read from the channel. * - * Consumes available bytes from channel buffers. When channel buffers - * are exhausted, reads more bytes from channel device into a new channel - * buffer. It is the caller's responsibility to free the channel buffers - * that have been exhausted. + * Consumes available bytes from channel buffers. When channel + * buffers are exhausted, reads more bytes from channel device into + * a new channel buffer. It is the caller's responsibility to + * free the channel buffers that have been exhausted. * * Results: - * The return value is -1 if there was an error reading from the channel, - * 0 otherwise. + * The return value is -1 if there was an error reading from the + * channel, 0 otherwise. * * Side effects: - * Status object keeps track of how much data from channel buffers has - * been consumed and where UTF-8 bytes should be stored. + * Status object keeps track of how much data from channel buffers + * has been consumed and where UTF-8 bytes should be stored. * *--------------------------------------------------------------------------- */ - + static int -FilterInputBytes( - Channel *chanPtr, /* Channel to read. */ - GetsState *gsPtr) /* Current state of gets operation. */ +FilterInputBytes(chanPtr, gsPtr) + Channel *chanPtr; /* Channel to read. */ + GetsState *gsPtr; /* Current state of gets operation. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; - char *raw, *rawStart, *dst; - int offset, toRead, dstNeeded, spaceLeft, result, rawLen; + char *raw, *rawStart, *rawEnd; + char *dst; + int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length; Tcl_Obj *objPtr; -#define ENCODING_LINESIZE 20 /* Lower bound on how many bytes to convert at - * a time. Since we don't know a priori how - * many bytes of storage this many source +#define ENCODING_LINESIZE 20 /* Lower bound on how many bytes to convert + * at a time. Since we don't know a priori + * how many bytes of storage this many source * bytes will use, we actually need at least * ENCODING_LINESIZE * TCL_MAX_UTF bytes of * room. */ @@ -5156,7 +3941,7 @@ FilterInputBytes( bufPtr = gsPtr->bufPtr; if (bufPtr != NULL) { bufPtr->nextRemoved += gsPtr->rawRead; - if (!IsBufferReady(bufPtr)) { + if (bufPtr->nextRemoved >= bufPtr->nextAdded) { bufPtr = bufPtr->nextPtr; } } @@ -5164,20 +3949,20 @@ FilterInputBytes( if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) { /* - * All channel buffers were exhausted and the caller still hasn't seen - * EOL. Need to read more bytes from the channel device. Side effect - * is to allocate another channel buffer. + * All channel buffers were exhausted and the caller still hasn't + * seen EOL. Need to read more bytes from the channel device. + * Side effect is to allocate another channel buffer. */ - read: - if (GotFlag(statePtr, CHANNEL_BLOCKED)) { - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + read: + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { gsPtr->charsWrote = 0; gsPtr->rawRead = 0; return -1; } - ResetFlag(statePtr, CHANNEL_BLOCKED); - } + statePtr->flags &= ~CHANNEL_BLOCKED; + } if (GetInput(chanPtr) != 0) { gsPtr->charsWrote = 0; gsPtr->rawRead = 0; @@ -5188,14 +3973,15 @@ FilterInputBytes( } /* - * Convert some of the bytes from the channel buffer to UTF-8. Space in - * objPtr's string rep is used to hold the UTF-8 characters. Grow the + * Convert some of the bytes from the channel buffer to UTF-8. Space in + * objPtr's string rep is used to hold the UTF-8 characters. Grow the * string rep if we need more space. */ - rawStart = RemovePoint(bufPtr); + rawStart = bufPtr->buf + bufPtr->nextRemoved; raw = rawStart; - rawLen = BytesLeft(bufPtr); + rawEnd = bufPtr->buf + bufPtr->nextAdded; + rawLen = rawEnd - rawStart; dst = *gsPtr->dstPtr; offset = dst - objPtr->bytes; @@ -5203,19 +3989,15 @@ FilterInputBytes( if (toRead > rawLen) { toRead = rawLen; } - dstNeeded = toRead * TCL_UTF_MAX; - spaceLeft = objPtr->length - offset; + dstNeeded = toRead * TCL_UTF_MAX + 1; + spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1; if (dstNeeded > spaceLeft) { - int length = offset + ((offset < dstNeeded) ? dstNeeded : offset); - - if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { + length = offset * 2; + if (offset < dstNeeded) { length = offset + dstNeeded; - if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { - dstNeeded = TCL_UTF_MAX - 1 + toRead; - length = offset + dstNeeded; - Tcl_SetObjLength(objPtr, length); - } } + length += TCL_UTF_MAX + 1; + Tcl_SetObjLength(objPtr, length); spaceLeft = length - offset; dst = objPtr->bytes + offset; *gsPtr->dstPtr = dst; @@ -5223,45 +4005,44 @@ FilterInputBytes( gsPtr->state = statePtr->inputEncodingState; result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen, statePtr->inputEncodingFlags, &statePtr->inputEncodingState, - dst, spaceLeft+1, &gsPtr->rawRead, &gsPtr->bytesWrote, + dst, spaceLeft, &gsPtr->rawRead, &gsPtr->bytesWrote, &gsPtr->charsWrote); /* * Make sure that if we go through 'gets', that we reset the - * TCL_ENCODING_START flag still. [Bug #523988] + * TCL_ENCODING_START flag still. [Bug #523988] */ - statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; if (result == TCL_CONVERT_MULTIBYTE) { /* * The last few bytes in this channel buffer were the start of a - * multibyte sequence. If this buffer was full, then move them to the - * next buffer so the bytes will be contiguous. + * multibyte sequence. If this buffer was full, then move them to + * the next buffer so the bytes will be contiguous. */ ChannelBuffer *nextPtr; int extra; - + nextPtr = bufPtr->nextPtr; - if (!IsBufferFull(bufPtr)) { + if (bufPtr->nextAdded < bufPtr->bufLength) { if (gsPtr->rawRead > 0) { /* - * Some raw bytes were converted to UTF-8. Fall through, + * Some raw bytes were converted to UTF-8. Fall through, * returning those UTF-8 characters because a EOL might be * present in them. */ - } else if (GotFlag(statePtr, CHANNEL_EOF)) { + } else if (statePtr->flags & CHANNEL_EOF) { /* * There was a partial character followed by EOF on the - * device. Fall through, returning that nothing was found. + * device. Fall through, returning that nothing was found. */ bufPtr->nextRemoved = bufPtr->nextAdded; } else { /* - * There are no more cached raw bytes left. See if we can get - * some more. + * There are no more cached raw bytes left. See if we can + * get some more. */ goto read; @@ -5273,8 +4054,8 @@ FilterInputBytes( statePtr->inQueueTail = nextPtr; } extra = rawLen - gsPtr->rawRead; - memcpy(nextPtr->buf + (BUFFER_PADDING - extra), - raw + gsPtr->rawRead, (size_t) extra); + memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra), + (VOID *) (raw + gsPtr->rawRead), (size_t) extra); nextPtr->nextRemoved -= extra; bufPtr->nextAdded -= extra; } @@ -5289,9 +4070,9 @@ FilterInputBytes( * * PeekAhead -- * - * Helper function used by Tcl_GetsObj(). Called when we've seen a \r at - * the end of the UTF-8 string and want to look ahead one character to - * see if it is a \n. + * Helper function used by Tcl_GetsObj(). Called when we've seen a + * \r at the end of the UTF-8 string and want to look ahead one + * character to see if it is a \n. * * Results: * *gsPtr->dstPtr is filled with a pointer to the start of the range of @@ -5307,14 +4088,13 @@ FilterInputBytes( */ static void -PeekAhead( - Channel *chanPtr, /* The channel to read. */ - char **dstEndPtr, /* Filled with pointer to end of new range of - * UTF-8 characters. */ - GetsState *gsPtr) /* Current state of gets operation. */ +PeekAhead(chanPtr, dstEndPtr, gsPtr) + Channel *chanPtr; /* The channel to read. */ + char **dstEndPtr; /* Filled with pointer to end of new range + * of UTF-8 characters. */ + GetsState *gsPtr; /* Current state of gets operation. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; Tcl_DriverBlockModeProc *blockModeProc; int bytesLeft; @@ -5323,24 +4103,24 @@ PeekAhead( /* * If there's any more raw input that's still buffered, we'll peek into - * that. Otherwise, only get more data from the channel driver if it looks - * like there might actually be more data. The assumption is that if the - * channel buffer is filled right up to the end, then there might be more - * data to read. + * that. Otherwise, only get more data from the channel driver if it + * looks like there might actually be more data. The assumption is that + * if the channel buffer is filled right up to the end, then there + * might be more data to read. */ blockModeProc = NULL; if (bufPtr->nextPtr == NULL) { - bytesLeft = BytesLeft(bufPtr) - gsPtr->rawRead; + bytesLeft = bufPtr->nextAdded - (bufPtr->nextRemoved + gsPtr->rawRead); if (bytesLeft == 0) { - if (!IsBufferFull(bufPtr)) { + if (bufPtr->nextAdded < bufPtr->bufLength) { /* * Don't peek ahead if last read was short read. */ - + goto cleanup; } - if (!GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) { blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr); if (blockModeProc == NULL) { /* @@ -5361,7 +4141,7 @@ PeekAhead( } return; - cleanup: + cleanup: bufPtr->nextRemoved += gsPtr->rawRead; gsPtr->rawRead = 0; gsPtr->totalChars += gsPtr->charsWrote; @@ -5374,8 +4154,8 @@ PeekAhead( * * CommonGetsCleanup -- * - * Helper function for Tcl_GetsObj() to restore the channel after a - * "gets" operation. + * Helper function for Tcl_GetsObj() to restore the channel after + * a "gets" operation. * * Results: * None. @@ -5385,19 +4165,19 @@ PeekAhead( * *--------------------------------------------------------------------------- */ - + static void -CommonGetsCleanup( - Channel *chanPtr) +CommonGetsCleanup(chanPtr, encoding) + Channel *chanPtr; + Tcl_Encoding encoding; { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr, *nextPtr; - + bufPtr = statePtr->inQueueHead; for ( ; bufPtr != NULL; bufPtr = nextPtr) { nextPtr = bufPtr->nextPtr; - if (IsBufferReady(bufPtr)) { + if (bufPtr->nextRemoved < bufPtr->nextAdded) { break; } RecycleBuffer(statePtr, bufPtr, 0); @@ -5409,20 +4189,20 @@ CommonGetsCleanup( /* * If any multi-byte characters were split across channel buffer * boundaries, the split-up bytes were moved to the next channel - * buffer by FilterInputBytes(). Move the bytes back to their original - * buffer because the caller could change the channel's encoding which - * could change the interpretation of whether those bytes really made - * up multi-byte characters after all. + * buffer by FilterInputBytes(). Move the bytes back to their + * original buffer because the caller could change the channel's + * encoding which could change the interpretation of whether those + * bytes really made up multi-byte characters after all. */ - + nextPtr = bufPtr->nextPtr; for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) { int extra; - extra = SpaceLeft(bufPtr); + extra = bufPtr->bufLength - bufPtr->nextAdded; if (extra > 0) { - memcpy(InsertPoint(bufPtr), - nextPtr->buf + (BUFFER_PADDING - extra), + memcpy((VOID *) (bufPtr->buf + bufPtr->nextAdded), + (VOID *) (nextPtr->buf + BUFFER_PADDING - extra), (size_t) extra); bufPtr->nextAdded += extra; nextPtr->nextRemoved = BUFFER_PADDING; @@ -5430,6 +4210,9 @@ CommonGetsCleanup( bufPtr = nextPtr; } } + if (statePtr->encoding == NULL) { + Tcl_FreeEncoding(encoding); + } } /* @@ -5437,16 +4220,16 @@ CommonGetsCleanup( * * Tcl_Read -- * - * Reads a given number of bytes from a channel. EOL and EOF translation - * is done on the bytes being read, so the number of bytes consumed from - * the channel may not be equal to the number of bytes stored in the - * destination buffer. + * Reads a given number of bytes from a channel. EOL and EOF + * translation is done on the bytes being read, so the the number + * of bytes consumed from the channel may not be equal to the + * number of bytes stored in the destination buffer. * * No encoding conversions are applied to the bytes being read. * * Results: - * The number of bytes read, or -1 on error. Use Tcl_GetErrno() to - * retrieve the error code for the error that occurred. + * The number of bytes read, or -1 on error. Use Tcl_GetErrno() + * to retrieve the error code for the error that occurred. * * Side effects: * May cause input to be buffered. @@ -5455,14 +4238,13 @@ CommonGetsCleanup( */ int -Tcl_Read( - Tcl_Channel chan, /* The channel from which to read. */ - char *dst, /* Where to store input read. */ - int bytesToRead) /* Maximum number of bytes to read. */ +Tcl_Read(chan, dst, bytesToRead) + Tcl_Channel chan; /* The channel from which to read. */ + char *dst; /* Where to store input read. */ + int bytesToRead; /* Maximum number of bytes to read. */ { - Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* * This operation should occur at the top of a channel stack. @@ -5474,7 +4256,7 @@ Tcl_Read( return -1; } - return DoRead(chanPtr, dst, bytesToRead, 0); + return DoRead(chanPtr, dst, bytesToRead); } /* @@ -5482,16 +4264,16 @@ Tcl_Read( * * Tcl_ReadRaw -- * - * Reads a given number of bytes from a channel. EOL and EOF translation - * is done on the bytes being read, so the number of bytes consumed from - * the channel may not be equal to the number of bytes stored in the - * destination buffer. + * Reads a given number of bytes from a channel. EOL and EOF + * translation is done on the bytes being read, so the the number + * of bytes consumed from the channel may not be equal to the + * number of bytes stored in the destination buffer. * * No encoding conversions are applied to the bytes being read. * * Results: - * The number of bytes read, or -1 on error. Use Tcl_GetErrno() to - * retrieve the error code for the error that occurred. + * The number of bytes read, or -1 on error. Use Tcl_GetErrno() + * to retrieve the error code for the error that occurred. * * Side effects: * May cause input to be buffered. @@ -5500,22 +4282,22 @@ Tcl_Read( */ int -Tcl_ReadRaw( - Tcl_Channel chan, /* The channel from which to read. */ - char *bufPtr, /* Where to store input read. */ - int bytesToRead) /* Maximum number of bytes to read. */ +Tcl_ReadRaw(chan, bufPtr, bytesToRead) + Tcl_Channel chan; /* The channel from which to read. */ + char *bufPtr; /* Where to store input read. */ + int bytesToRead; /* Maximum number of bytes to read. */ { - Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - int nread, result, copied, copiedNow; + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; /* state info for channel */ + int nread, result; + int copied, copiedNow; /* * The check below does too much because it will reject a call to this * function with a channel which is part of an 'fcopy'. But we have to - * allow this here or else the chaining in the transformation drivers will - * fail with 'file busy' error instead of retrieving and transforming the - * data to copy. + * allow this here or else the chaining in the transformation drivers + * will fail with 'file busy' error instead of retrieving and + * transforming the data to copy. * * We let the check procedure now believe that there is no fcopy in * progress. A better solution than this might be an additional flag @@ -5527,109 +4309,102 @@ Tcl_ReadRaw( } /* - * Check for information in the push-back buffers. If there is some, use - * it. Go to the driver only if there is none (anymore) and the caller - * requests more bytes. + * Check for information in the push-back buffers. If there is + * some, use it. Go to the driver only if there is none (anymore) + * and the caller requests more bytes. */ for (copied = 0; copied < bytesToRead; copied += copiedNow) { - copiedNow = CopyBuffer(chanPtr, bufPtr + copied, - bytesToRead - copied); - if (copiedNow == 0) { - if (GotFlag(statePtr, CHANNEL_EOF)) { + copiedNow = CopyBuffer(chanPtr, bufPtr + copied, + bytesToRead - copied); + if (copiedNow == 0) { + if (statePtr->flags & CHANNEL_EOF) { goto done; - } - if (GotFlag(statePtr, CHANNEL_BLOCKED)) { - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + } + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { goto done; - } - ResetFlag(statePtr, CHANNEL_BLOCKED); - } + } + statePtr->flags &= (~(CHANNEL_BLOCKED)); + } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* - * [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. + /* [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 (GotFlag(statePtr, CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !GotFlag(statePtr, CHANNEL_HAS_MORE_DATA)) { - /* - * We bypass the driver; it would block as no data is - * available. - */ + if ((statePtr->flags & CHANNEL_NONBLOCKING) && + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { - nread = -1; - result = EWOULDBLOCK; - } else + /* 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 = ChanRead(chanPtr, 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 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)) { - SetFlag(statePtr, CHANNEL_BLOCKED); + + if (nread < (bytesToRead - copied)) { + statePtr->flags |= CHANNEL_BLOCKED; } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - if (nread <= (bytesToRead - copied)) { - /* - * [Bug 943274] We have read the available data, clear - * flag. - */ - - ResetFlag(statePtr, CHANNEL_HAS_MORE_DATA); + 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) { - SetFlag(statePtr, 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; } - SetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags |= CHANNEL_BLOCKED; result = EAGAIN; } Tcl_SetErrno(result); return -1; - } + } return copied + nread; - } + } } - done: +done: return copied; } @@ -5638,39 +4413,39 @@ Tcl_ReadRaw( * * Tcl_ReadChars -- * - * Reads from the channel until the requested number of characters have - * been seen, EOF is seen, or the channel would block. EOL and EOF - * translation is done. If reading binary data, the raw bytes are wrapped - * in a Tcl byte array object. Otherwise, the raw bytes are converted to - * UTF-8 using the channel's current encoding and stored in a Tcl string - * object. + * Reads from the channel until the requested number of characters + * have been seen, EOF is seen, or the channel would block. EOL + * and EOF translation is done. If reading binary data, the raw + * bytes are wrapped in a Tcl byte array object. Otherwise, the raw + * bytes are converted to UTF-8 using the channel's current encoding + * and stored in a Tcl string object. * * Results: - * The number of characters read, or -1 on error. Use Tcl_GetErrno() to - * retrieve the error code for the error that occurred. + * The number of characters read, or -1 on error. Use Tcl_GetErrno() + * to retrieve the error code for the error that occurred. * * Side effects: * May cause input to be buffered. * *--------------------------------------------------------------------------- */ - + int -Tcl_ReadChars( - Tcl_Channel chan, /* The channel to read. */ - Tcl_Obj *objPtr, /* Input data is stored in this object. */ - int toRead, /* Maximum number of characters to store, or - * -1 to read all available data (up to EOF or - * when channel blocks). */ - int appendFlag) /* If non-zero, data read from the channel - * will be appended to the object. Otherwise, +Tcl_ReadChars(chan, objPtr, toRead, appendFlag) + Tcl_Channel chan; /* The channel to read. */ + Tcl_Obj *objPtr; /* Input data is stored in this object. */ + int toRead; /* Maximum number of characters to store, + * or -1 to read all available data (up to EOF + * or when channel blocks). */ + int appendFlag; /* If non-zero, data read from the channel + * will be appended to the object. Otherwise, * the data will replace the existing contents * of the object. */ -{ - Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ +{ + Channel* chanPtr = (Channel *) chan; + ChannelState* statePtr = chanPtr->state; /* state info for channel */ + /* * This operation should occur at the top of a channel stack. */ @@ -5678,53 +4453,52 @@ Tcl_ReadChars( 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); } /* *--------------------------------------------------------------------------- * * DoReadChars -- * - * Reads from the channel until the requested number of characters have - * been seen, EOF is seen, or the channel would block. EOL and EOF - * translation is done. If reading binary data, the raw bytes are wrapped - * in a Tcl byte array object. Otherwise, the raw bytes are converted to - * UTF-8 using the channel's current encoding and stored in a Tcl string - * object. + * Reads from the channel until the requested number of characters + * have been seen, EOF is seen, or the channel would block. EOL + * and EOF translation is done. If reading binary data, the raw + * bytes are wrapped in a Tcl byte array object. Otherwise, the raw + * bytes are converted to UTF-8 using the channel's current encoding + * and stored in a Tcl string object. * * Results: - * The number of characters read, or -1 on error. Use Tcl_GetErrno() to - * retrieve the error code for the error that occurred. + * The number of characters read, or -1 on error. Use Tcl_GetErrno() + * to retrieve the error code for the error that occurred. * * Side effects: * May cause input to be buffered. * *--------------------------------------------------------------------------- */ - + static int -DoReadChars( - Channel *chanPtr, /* The channel to read. */ - Tcl_Obj *objPtr, /* Input data is stored in this object. */ - int toRead, /* Maximum number of characters to store, or - * -1 to read all available data (up to EOF or - * when channel blocks). */ - int appendFlag) /* If non-zero, data read from the channel - * will be appended to the object. Otherwise, +DoReadChars(chanPtr, objPtr, toRead, appendFlag) + Channel* chanPtr; /* The channel to read. */ + Tcl_Obj *objPtr; /* Input data is stored in this object. */ + int toRead; /* Maximum number of characters to store, + * or -1 to read all available data (up to EOF + * or when channel blocks). */ + int appendFlag; /* If non-zero, data read from the channel + * will be appended to the object. Otherwise, * the data will replace the existing contents * of the object. */ + { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelBuffer *bufPtr; int offset, factor, copied, copiedNow, result; Tcl_Encoding encoding; @@ -5734,30 +4508,28 @@ DoReadChars( * 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) { Tcl_SetByteArrayLength(objPtr, 0); } else { Tcl_SetObjLength(objPtr, 0); - - /* - * We're going to access objPtr->bytes directly, so we must ensure - * that this is actually a string object (otherwise it might have - * been pure Unicode). + /* + * We're going to access objPtr->bytes directly, so + * we must ensure that this is actually a string + * object (otherwise it might have been pure Unicode). */ - - TclGetString(objPtr); + Tcl_GetString(objPtr); } offset = 0; } else { if (encoding == NULL) { Tcl_GetByteArrayFromObj(objPtr, &offset); } else { - TclGetStringFromObj(objPtr, &offset); + Tcl_GetStringFromObj(objPtr, &offset); } } @@ -5776,9 +4548,10 @@ DoReadChars( */ bufPtr = statePtr->inQueueHead; - if (IsBufferEmpty(bufPtr)) { - ChannelBuffer *nextPtr = bufPtr->nextPtr; + if (bufPtr->nextRemoved == bufPtr->nextAdded) { + ChannelBuffer *nextPtr; + nextPtr = bufPtr->nextPtr; RecycleBuffer(statePtr, bufPtr, 0); statePtr->inQueueHead = nextPtr; if (nextPtr == NULL) { @@ -5786,16 +4559,15 @@ DoReadChars( } } } - if (copiedNow < 0) { - if (GotFlag(statePtr, CHANNEL_EOF)) { + if (statePtr->flags & CHANNEL_EOF) { break; } - if (GotFlag(statePtr, CHANNEL_BLOCKED)) { - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { break; } - ResetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags &= ~CHANNEL_BLOCKED; } result = GetInput(chanPtr); if (result != 0) { @@ -5810,49 +4582,41 @@ DoReadChars( toRead -= copiedNow; } } - - ResetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags &= ~CHANNEL_BLOCKED; if (encoding == NULL) { Tcl_SetByteArrayLength(objPtr, offset); } else { Tcl_SetObjLength(objPtr, offset); } + done: /* - * Update the notifier state so we don't block while there is still data - * in the buffers. + * Update the notifier state so we don't block while there is still + * data in the buffers. */ - done: - /* - * Regenerate the top channel, in case it was changed due to - * self-modifying reflected transforms. - */ - - chanPtr = statePtr->topChanPtr; - UpdateInterest(chanPtr); return copied; } - /* *--------------------------------------------------------------------------- * * ReadBytes -- * - * Reads from the channel until the requested number of bytes have been - * seen, EOF is seen, or the channel would block. Bytes from the channel - * are stored in objPtr as a ByteArray object. EOL and EOF translation - * are done. + * Reads from the channel until the requested number of bytes have + * been seen, EOF is seen, or the channel would block. Bytes from + * the channel are stored in objPtr as a ByteArray object. EOL + * and EOF translation are done. * - * 'bytesToRead' can safely be a very large number because space is only - * allocated to hold data read from the channel as needed. + * 'bytesToRead' can safely be a very large number because + * space is only allocated to hold data read from the channel + * as needed. * * Results: - * The return value is the number of bytes appended to the object and - * *offsetPtr is filled with the total number of bytes in the object - * (greater than the return value if there were already bytes in the - * object). + * The return value is the number of bytes appended to the object + * and *offsetPtr is filled with the total number of bytes in the + * object (greater than the return value if there were already bytes + * in the object). * * Side effects: * None. @@ -5861,24 +4625,25 @@ DoReadChars( */ static int -ReadBytes( - ChannelState *statePtr, /* State of the channel to read. */ - Tcl_Obj *objPtr, /* Input data is appended to this ByteArray - * object. Its length is how much space has - * been allocated to hold data, not how many - * bytes of data have been stored in the +ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr) + ChannelState *statePtr; /* State of the channel to read. */ + Tcl_Obj *objPtr; /* Input data is appended to this ByteArray + * object. Its length is how much space + * has been allocated to hold data, not how + * many bytes of data have been stored in the * object. */ - int bytesToRead, /* Maximum number of bytes to store, or < 0 to - * get all available bytes. Bytes are obtained - * from the first buffer in the queue - even - * if this number is larger than the number of - * bytes available in the first buffer, only - * the bytes from the first buffer are + int bytesToRead; /* Maximum number of bytes to store, + * or < 0 to get all available bytes. + * Bytes are obtained from the first + * buffer in the queue -- even if this number + * is larger than the number of bytes + * available in the first buffer, only the + * bytes from the first buffer are * returned. */ - int *offsetPtr) /* On input, contains how many bytes of objPtr - * have been used to hold data. On output, - * filled with how many bytes are now being - * used. */ + int *offsetPtr; /* On input, contains how many bytes of + * objPtr have been used to hold data. On + * output, filled with how many bytes are now + * being used. */ { int toRead, srcLen, offset, length, srcRead, dstWrote; ChannelBuffer *bufPtr; @@ -5886,9 +4651,9 @@ ReadBytes( offset = *offsetPtr; - bufPtr = statePtr->inQueueHead; - src = RemovePoint(bufPtr); - srcLen = BytesLeft(bufPtr); + bufPtr = statePtr->inQueueHead; + src = bufPtr->buf + bufPtr->nextRemoved; + srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; toRead = bytesToRead; if ((unsigned) toRead > (unsigned) srcLen) { @@ -5898,9 +4663,9 @@ ReadBytes( dst = (char *) Tcl_GetByteArrayFromObj(objPtr, &length); if (toRead > length - offset - 1) { /* - * Double the existing size of the object or make enough room to hold - * all the characters we may get from the source buffer, whichever is - * larger. + * Double the existing size of the object or make enough room to + * hold all the characters we may get from the source buffer, + * whichever is larger. */ length = offset * 2; @@ -5911,8 +4676,8 @@ ReadBytes( } dst += offset; - if (GotFlag(statePtr, INPUT_NEED_NL)) { - ResetFlag(statePtr, INPUT_NEED_NL); + if (statePtr->flags & INPUT_NEED_NL) { + statePtr->flags &= ~INPUT_NEED_NL; if ((srcLen == 0) || (*src != '\n')) { *dst = '\r'; *offsetPtr += 1; @@ -5941,21 +4706,21 @@ ReadBytes( * * ReadChars -- * - * Reads from the channel until the requested number of UTF-8 characters - * have been seen, EOF is seen, or the channel would block. Raw bytes - * from the channel are converted to UTF-8 and stored in objPtr. EOL and - * EOF translation is done. - * - * 'charsToRead' can safely be a very large number because space is only - * allocated to hold data read from the channel as needed. + * Reads from the channel until the requested number of UTF-8 + * characters have been seen, EOF is seen, or the channel would + * block. Raw bytes from the channel are converted to UTF-8 + * and stored in objPtr. EOL and EOF translation is done. * - * 'charsToRead' may *not* be 0. + * 'charsToRead' can safely be a very large number because + * space is only allocated to hold data read from the channel + * as needed. * * Results: - * The return value is the number of characters appended to the object, - * *offsetPtr is filled with the number of bytes that were appended, and - * *factorPtr is filled with the expansion factor used to guess how many - * bytes of UTF-8 to allocate to hold N source bytes. + * The return value is the number of characters appended to + * the object, *offsetPtr is filled with the number of bytes that + * were appended, and *factorPtr is filled with the expansion + * factor used to guess how many bytes of UTF-8 to allocate to + * hold N source bytes. * * Side effects: * None. @@ -5964,31 +4729,31 @@ ReadBytes( */ static int -ReadChars( - ChannelState *statePtr, /* State of channel to read. */ - Tcl_Obj *objPtr, /* Input data is appended to this object. +ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) + ChannelState *statePtr; /* State of channel to read. */ + Tcl_Obj *objPtr; /* Input data is appended to this object. * objPtr->length is how much space has been * allocated to hold data, not how many bytes * of data have been stored in the object. */ - int charsToRead, /* Maximum number of characters to store, or - * -1 to get all available characters. + int charsToRead; /* Maximum number of characters to store, + * or -1 to get all available characters. * Characters are obtained from the first * buffer in the queue -- even if this number * is larger than the number of characters * available in the first buffer, only the * characters from the first buffer are * returned. */ - int *offsetPtr, /* On input, contains how many bytes of objPtr - * have been used to hold data. On output, - * filled with how many bytes are now being - * used. */ - int *factorPtr) /* On input, contains a guess of how many + int *offsetPtr; /* On input, contains how many bytes of + * objPtr have been used to hold data. On + * output, filled with how many bytes are now + * being used. */ + int *factorPtr; /* On input, contains a guess of how many * bytes need to be allocated to hold the * result of converting N source bytes to - * UTF-8. On output, contains another guess + * UTF-8. On output, contains another guess * based on the data seen so far. */ { - int toRead, factor, offset, spaceLeft, srcLen, dstNeeded; + int toRead, factor, offset, spaceLeft, length, srcLen, dstNeeded; int srcRead, dstWrote, numChars, dstRead; ChannelBuffer *bufPtr; char *src, *dst; @@ -5998,48 +4763,45 @@ ReadChars( factor = *factorPtr; offset = *offsetPtr; - bufPtr = statePtr->inQueueHead; - src = RemovePoint(bufPtr); - srcLen = BytesLeft(bufPtr); + bufPtr = statePtr->inQueueHead; + src = bufPtr->buf + bufPtr->nextRemoved; + srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; toRead = charsToRead; - if ((unsigned) toRead > (unsigned) srcLen) { + if ((unsigned)toRead > (unsigned)srcLen) { toRead = srcLen; } /* - * 'factor' is how much we guess that the bytes in the source buffer will - * expand when converted to UTF-8 chars. This guess comes from analyzing - * how many characters were produced by the previous pass. + * 'factor' is how much we guess that the bytes in the source buffer + * will expand when converted to UTF-8 chars. This guess comes from + * analyzing how many characters were produced by the previous + * pass. */ - dstNeeded = TCL_UTF_MAX - 1 + toRead * factor / UTF_EXPANSION_FACTOR; - spaceLeft = objPtr->length - offset; + dstNeeded = toRead * factor / UTF_EXPANSION_FACTOR; + spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1; if (dstNeeded > spaceLeft) { /* - * Double the existing size of the object or make enough room to hold - * all the characters we want from the source buffer, whichever is - * larger. + * Double the existing size of the object or make enough room to + * hold all the characters we want from the source buffer, + * whichever is larger. */ - int length = offset + ((offset < dstNeeded) ? dstNeeded : offset); - - if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { + length = offset * 2; + if (offset < dstNeeded) { length = offset + dstNeeded; - if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { - dstNeeded = TCL_UTF_MAX - 1 + toRead; - length = offset + dstNeeded; - Tcl_SetObjLength(objPtr, length); - } } spaceLeft = length - offset; + length += TCL_UTF_MAX + 1; + Tcl_SetObjLength(objPtr, length); } if (toRead == srcLen) { /* - * Want to convert the whole buffer in one pass. If we have enough - * space, convert it using all available space in object rather than - * using the factor. + * Want to convert the whole buffer in one pass. If we have + * enough space, convert it using all available space in object + * rather than using the factor. */ dstNeeded = spaceLeft; @@ -6047,69 +4809,72 @@ ReadChars( dst = objPtr->bytes + offset; /* - * [Bug 1462248]: The cause of the crash reported in this bug is this: + * SF Tcl Bug 1462248 + * The cause of the crash reported in the referenced bug is this: * * - ReadChars, called with a single buffer, with a incomplete - * multi-byte character at the end (only the first byte of it). + * multi-byte character at the end (only the first byte of it). * - Encoding translation fails, asks for more data * - Data is read, and eof is reached, TCL_ENCODING_END (TEE) is set. - * - ReadChar is called again, converts the first buffer, but due to TEE - * it does not check for incomplete multi-byte data, and the character - * just after the end of the first buffer is a valid completion of the - * multi-byte header in the actual buffer. The conversion reads more - * characters from the buffer then present. This causes nextRemoved to - * overshoot nextAdded and the next reads compute a negative srcLen, - * cause further translations to fail, causing copying of data into the - * next buffer using bad arguments, causing the mecpy for to eventually - * fail. + * - ReadChar is called again, converts the first buffer, but due + * to TEE it does not check for incomplete multi-byte data, and the + * character just after the end of the first buffer is a valid + * completion of the multi-byte header in the actual buffer. The + * conversion reads more characters from the buffer then present. + * This causes nextRemoved to overshoot nextAdded and the next + * reads compute a negative srcLen, cause further translations to + * fail, causing copying of data into the next buffer using bad + * arguments, causing the mecpy for to eventually fail. * - * In the end it is a memory access bug spiraling out of control if the - * conditions are _just so_. And ultimate cause is that TEE is given to a - * conversion where it should not. TEE signals that this is the last - * buffer. Except in our case it is not. + * In the end it is a memory access bug spiraling out of control + * if the conditions are _just so_. And ultimate cause is that TEE + * is given to a conversion where it should not. TEE signals that + * this is the last buffer. Except in our case it is not. * - * My solution is to suppress TEE if the first buffer is not the last. We - * will eventually need it given that EOF has been reached, but not right - * now. This is what the new flag "endEncSuppressFlag" is for. + * My solution is to suppress TEE if the first buffer is not the + * last. We will eventually need it given that EOF has been + * reached, but not right now. This is what the new flag + * "endEncSuppressFlag" is for. * - * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind the - * actual buffer has been fixed as well, and fixes the problem with the - * crash too, but this would still allow the generic layer to - * accidentially break a multi-byte sequence if the conditions are just - * right, because again the ExternalToUtf would be successful where it - * should not. + * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind + * the actual buffer has been fixed as well, and fixes the problem + * with the crash too, but this would still allow the generic + * layer to accidentially break a multi-byte sequence if the + * conditions are just right, because again the ExternalToUtf + * would be successful where it should not. */ if ((statePtr->inputEncodingFlags & TCL_ENCODING_END) && - (bufPtr->nextPtr != NULL)) { - /* - * TEE is set for a buffer which is not the last. Squash it for now, - * and restore it later, before yielding control to our caller. + (bufPtr->nextPtr != NULL)) { + + /* TEE is set for a buffer which is not the last. Squash it + * for now, and restore it later, before yielding control to + * our caller. */ - statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; - encEndFlagSuppressed = 1; + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + encEndFlagSuppressed = 1; } oldState = statePtr->inputEncodingState; - if (GotFlag(statePtr, INPUT_NEED_NL)) { + if (statePtr->flags & INPUT_NEED_NL) { /* * We want a '\n' because the last character we saw was '\r'. */ - ResetFlag(statePtr, INPUT_NEED_NL); + statePtr->flags &= ~INPUT_NEED_NL; Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen, statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars); if ((dstWrote > 0) && (*dst == '\n')) { /* - * The next char was a '\n'. Consume it and produce a '\n'. + * The next char was a '\n'. Consume it and produce a '\n'. */ bufPtr->nextRemoved += srcRead; } else { /* - * The next char was not a '\n'. Produce a '\r'. + * The next char was not a '\n'. Produce a '\r'. */ *dst = '\r'; @@ -6120,64 +4885,67 @@ ReadChars( if (encEndFlagSuppressed) { statePtr->inputEncodingFlags |= TCL_ENCODING_END; } - return 1; + return 1; } Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen, statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst, - dstNeeded + 1, &srcRead, &dstWrote, &numChars); + dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); if (encEndFlagSuppressed) { - statePtr->inputEncodingFlags |= TCL_ENCODING_END; + statePtr->inputEncodingFlags |= TCL_ENCODING_END; } if (srcRead == 0) { /* - * Not enough bytes in src buffer to make a complete char. Copy the - * bytes to the next buffer to make a new contiguous string, then tell - * the caller to fill the buffer with more bytes. + * Not enough bytes in src buffer to make a complete char. Copy + * the bytes to the next buffer to make a new contiguous string, + * then tell the caller to fill the buffer with more bytes. */ 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. [Bug 478856] + * file event can be delivered. * - * The exception to this is if the input buffer was completely - * empty before we tried to convert its contents. Nothing in, - * nothing out, and no incomplete character data. The - * conversion before the current one was complete. + * SF #478856. + * + * The exception to this is if the input buffer was + * completely empty before we tried to convert its + * contents. Nothing in, nothing out, and no incomplete + * character data. The conversion before the current one + * was complete. */ - SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + statePtr->flags |= CHANNEL_NEED_MORE_DATA; } return -1; } - /* - * Space is made at the beginning of the buffer to copy the previous - * unused bytes there. Check first if the buffer we are using actually - * has enough space at its beginning for the data we are copying. - * Because if not we will write over the buffer management - * information, especially the 'nextPtr'. + /* Space is made at the beginning of the buffer to copy the + * previous unused bytes there. Check first if the buffer we + * are using actually has enough space at its beginning for + * the data we are copying. Because if not we will write over the + * buffer management information, especially the 'nextPtr'. * - * Note that the BUFFER_PADDING (See AllocChannelBuffer) is used to - * prevent exactly this situation. I.e. it should never happen. - * Therefore it is ok to panic should it happen despite the - * precautions. + * Note that the BUFFER_PADDING (See AllocChannelBuffer) is + * used to prevent exactly this situation. I.e. it should + * never happen. Therefore it is ok to panic should it happen + * despite the precautions. */ if (nextPtr->nextRemoved - srcLen < 0) { - Tcl_Panic("Buffer Underflow, BUFFER_PADDING not enough"); + Tcl_Panic ("Buffer Underflow, BUFFER_PADDING not enough"); } nextPtr->nextRemoved -= srcLen; - memcpy(RemovePoint(nextPtr), src, (size_t) srcLen); + memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src, + (size_t) srcLen); RecycleBuffer(statePtr, bufPtr, 0); statePtr->inQueueHead = nextPtr; return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr); @@ -6186,12 +4954,12 @@ ReadChars( dstRead = dstWrote; if (TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead) != 0) { /* - * Hit EOF char. How many bytes of src correspond to where the EOF was - * located in dst? Run the conversion again with an output buffer just - * big enough to hold the data so we can get the correct value for - * srcRead. + * Hit EOF char. How many bytes of src correspond to where the + * EOF was located in dst? Run the conversion again with an + * output buffer just big enough to hold the data so we can + * get the correct value for srcRead. */ - + if (dstWrote == 0) { return -1; } @@ -6200,23 +4968,24 @@ ReadChars( statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst, dstRead + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead); - } + } /* - * The number of characters that we got may be less than the number that - * we started with because "\r\n" sequences may have been turned into just - * '\n' in dst. + * The number of characters that we got may be less than the number + * that we started with because "\r\n" sequences may have been + * turned into just '\n' in dst. */ - numChars -= dstRead - dstWrote; + numChars -= (dstRead - dstWrote); if ((unsigned) numChars > (unsigned) toRead) { /* * Got too many chars. */ - const char *eof = Tcl_UtfAtIndex(dst, toRead); + CONST char *eof; + eof = Tcl_UtfAtIndex(dst, toRead); statePtr->inputEncodingState = oldState; Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen, statePtr->inputEncodingFlags, &statePtr->inputEncodingState, @@ -6240,12 +5009,12 @@ ReadChars( * * TranslateInputEOL -- * - * Perform input EOL and EOF translation on the source buffer, leaving - * the translated result in the destination buffer. + * Perform input EOL and EOF translation on the source buffer, + * leaving the translated result in the destination buffer. * * Results: * The return value is 1 if the EOF character was found when copying - * bytes to the destination buffer, 0 otherwise. + * bytes to the destination buffer, 0 otherwise. * * Side effects: * None. @@ -6254,23 +5023,23 @@ ReadChars( */ static int -TranslateInputEOL( - ChannelState *statePtr, /* Channel being read, for EOL translation and - * EOF character. */ - char *dstStart, /* Output buffer filled with chars by applying - * appropriate EOL translation to source - * characters. */ - const char *srcStart, /* Source characters. */ - int *dstLenPtr, /* On entry, the maximum length of output - * buffer in bytes; must be <= *srcLenPtr. On +TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) + ChannelState *statePtr; /* Channel being read, for EOL translation + * and EOF character. */ + char *dstStart; /* Output buffer filled with chars by + * applying appropriate EOL translation to + * source characters. */ + CONST char *srcStart; /* Source characters. */ + int *dstLenPtr; /* On entry, the maximum length of output + * buffer in bytes; must be <= *srcLenPtr. On * exit, the number of bytes actually used in * output buffer. */ - int *srcLenPtr) /* On entry, the length of source buffer. On - * exit, the number of bytes read from the - * source buffer. */ + int *srcLenPtr; /* On entry, the length of source buffer. + * On exit, the number of bytes read from + * the source buffer. */ { int dstLen, srcLen, inEofChar; - const char *eof; + CONST char *eof; dstLen = *dstLenPtr; @@ -6278,14 +5047,15 @@ TranslateInputEOL( inEofChar = statePtr->inEofChar; if (inEofChar != '\0') { /* - * Find EOF in translated buffer then compress out the EOL. The source - * buffer may be much longer than the destination buffer - we only - * want to return EOF if the EOF has been copied to the destination - * buffer. + * Find EOF in translated buffer then compress out the EOL. The + * source buffer may be much longer than the destination buffer -- + * we only want to return EOF if the EOF has been copied to the + * destination buffer. */ - const char *src, *srcMax = srcStart + *srcLenPtr; + CONST char *src, *srcMax; + srcMax = srcStart + *srcLenPtr; for (src = srcStart; src < srcMax; src++) { if (*src == inEofChar) { eof = src; @@ -6299,104 +5069,106 @@ TranslateInputEOL( } } switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: - if (dstStart != srcStart) { - memcpy(dstStart, srcStart, (size_t) dstLen); - } - srcLen = dstLen; - break; - case TCL_TRANSLATE_CR: { - char *dst, *dstEnd; - - if (dstStart != srcStart) { - memcpy(dstStart, srcStart, (size_t) dstLen); - } - dstEnd = dstStart + dstLen; - for (dst = dstStart; dst < dstEnd; dst++) { - if (*dst == '\r') { - *dst = '\n'; + case TCL_TRANSLATE_LF: { + if (dstStart != srcStart) { + memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); } + srcLen = dstLen; + break; } - srcLen = dstLen; - break; - } - case TCL_TRANSLATE_CRLF: { - char *dst; - const char *src, *srcEnd, *srcMax; - - dst = dstStart; - src = srcStart; - srcEnd = srcStart + dstLen; - srcMax = srcStart + *srcLenPtr; - - for ( ; src < srcEnd; ) { - if (*src == '\r') { - src++; - if (src >= srcMax) { - SetFlag(statePtr, INPUT_NEED_NL); - } else if (*src == '\n') { - *dst++ = *src++; + case TCL_TRANSLATE_CR: { + char *dst, *dstEnd; + + if (dstStart != srcStart) { + memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); + } + dstEnd = dstStart + dstLen; + for (dst = dstStart; dst < dstEnd; dst++) { + if (*dst == '\r') { + *dst = '\n'; + } + } + srcLen = dstLen; + break; + } + case TCL_TRANSLATE_CRLF: { + char *dst; + CONST char *src, *srcEnd, *srcMax; + + dst = dstStart; + src = srcStart; + srcEnd = srcStart + dstLen; + srcMax = srcStart + *srcLenPtr; + + for ( ; src < srcEnd; ) { + if (*src == '\r') { + src++; + if (src >= srcMax) { + statePtr->flags |= INPUT_NEED_NL; + } else if (*src == '\n') { + *dst++ = *src++; + } else { + *dst++ = '\r'; + } } else { - *dst++ = '\r'; + *dst++ = *src++; } - } else { - *dst++ = *src++; } + srcLen = src - srcStart; + dstLen = dst - dstStart; + break; } - srcLen = src - srcStart; - dstLen = dst - dstStart; - break; - } - case TCL_TRANSLATE_AUTO: { - char *dst; - const char *src, *srcEnd, *srcMax; + case TCL_TRANSLATE_AUTO: { + char *dst; + CONST char *src, *srcEnd, *srcMax; - dst = dstStart; - src = srcStart; - srcEnd = srcStart + dstLen; - srcMax = srcStart + *srcLenPtr; + dst = dstStart; + src = srcStart; + srcEnd = srcStart + dstLen; + srcMax = srcStart + *srcLenPtr; - if (GotFlag(statePtr, INPUT_SAW_CR) && (src < srcMax)) { - if (*src == '\n') { - src++; + if ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) { + if (*src == '\n') { + src++; + } + statePtr->flags &= ~INPUT_SAW_CR; } - ResetFlag(statePtr, INPUT_SAW_CR); - } - for ( ; src < srcEnd; ) { - if (*src == '\r') { - src++; - if (src >= srcMax) { - SetFlag(statePtr, INPUT_SAW_CR); - } else if (*src == '\n') { - if (srcEnd < srcMax) { - srcEnd++; - } + for ( ; src < srcEnd; ) { + if (*src == '\r') { src++; + if (src >= srcMax) { + statePtr->flags |= INPUT_SAW_CR; + } else if (*src == '\n') { + if (srcEnd < srcMax) { + srcEnd++; + } + src++; + } + *dst++ = '\n'; + } else { + *dst++ = *src++; } - *dst++ = '\n'; - } else { - *dst++ = *src++; } + srcLen = src - srcStart; + dstLen = dst - dstStart; + break; + } + default: { /* lint. */ + return 0; } - srcLen = src - srcStart; - dstLen = dst - dstStart; - break; - } - default: - return 0; } *dstLenPtr = dstLen; if ((eof != NULL) && (srcStart + srcLen >= eof)) { /* - * EOF character was seen in EOL translated range. Leave current file - * position pointing at the EOF character, but don't store the EOF - * character in the output string. + * EOF character was seen in EOL translated range. Leave current + * file position pointing at the EOF character, but don't store the + * EOF character in the output string. */ - SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); statePtr->inputEncodingFlags |= TCL_ENCODING_END; - ResetFlag(statePtr, INPUT_SAW_CR | INPUT_NEED_NL); + statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL); return 1; } @@ -6409,8 +5181,8 @@ TranslateInputEOL( * * Tcl_Ungets -- * - * Causes the supplied string to be added to the input queue of the - * channel, at either the head or tail of the queue. + * Causes the supplied string to be added to the input queue of + * the channel, at either the head or tail of the queue. * * Results: * The number of bytes stored in the channel, or -1 on error. @@ -6422,17 +5194,17 @@ TranslateInputEOL( */ int -Tcl_Ungets( - Tcl_Channel chan, /* The channel for which to add the input. */ - const char *str, /* The input itself. */ - int len, /* The length of the input. */ - int atEnd) /* If non-zero, add at end of queue; otherwise - * add at head of queue. */ +Tcl_Ungets(chan, str, len, atEnd) + Tcl_Channel chan; /* The channel for which to add the input. */ + CONST char *str; /* The input itself. */ + int len; /* The length of the input. */ + int atEnd; /* If non-zero, add at end of queue; otherwise + * add at head of queue. */ { Channel *chanPtr; /* The real IO channel. */ ChannelState *statePtr; /* State of actual channel. */ ChannelBuffer *bufPtr; /* Buffer to contain the data. */ - int flags; + int i, flags; chanPtr = (Channel *) chan; statePtr = chanPtr->state; @@ -6446,7 +5218,7 @@ Tcl_Ungets( /* * CheckChannelErrors clears too many flag bits in this one case. */ - + flags = statePtr->flags; if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { len = -1; @@ -6455,40 +5227,42 @@ Tcl_Ungets( statePtr->flags = flags; /* - * If we have encountered a sticky EOF, just punt without storing (sticky - * EOF is set if we have seen the input eofChar, to prevent reading beyond - * the eofChar). Otherwise, clear the EOF flags, and clear the BLOCKED - * bit. We want to discover these conditions anew in each operation. + * If we have encountered a sticky EOF, just punt without storing. + * (sticky EOF is set if we have seen the input eofChar, to prevent + * reading beyond the eofChar). Otherwise, clear the EOF flags, and + * clear the BLOCKED bit. We want to discover these conditions anew + * in each operation. */ - if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) { + if (statePtr->flags & CHANNEL_STICKY_EOF) { goto done; } - ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_EOF); + statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF)); bufPtr = AllocChannelBuffer(len); - memcpy(InsertPoint(bufPtr), str, (size_t) len); - bufPtr->nextAdded += len; + for (i = 0; i < len; i++) { + bufPtr->buf[bufPtr->nextAdded++] = str[i]; + } - if (statePtr->inQueueHead == NULL) { - bufPtr->nextPtr = NULL; - statePtr->inQueueHead = bufPtr; - statePtr->inQueueTail = bufPtr; + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { + bufPtr->nextPtr = (ChannelBuffer *) NULL; + statePtr->inQueueHead = bufPtr; + statePtr->inQueueTail = bufPtr; } else if (atEnd) { - bufPtr->nextPtr = 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: /* - * Update the notifier state so we don't block while there is still data - * in the buffers. + * Update the notifier state so we don't block while there is still + * data in the buffers. */ - done: UpdateInterest(chanPtr); return len; } @@ -6510,14 +5284,12 @@ Tcl_Ungets( */ int -Tcl_Flush( - Tcl_Channel chan) /* The Channel to flush. */ +Tcl_Flush(chan) + Tcl_Channel chan; /* The Channel to flush. */ { - int result; /* Of calling FlushChannel. */ - Channel *chanPtr = (Channel *) chan; - /* The actual channel. */ - ChannelState *statePtr = chanPtr->state; - /* State of actual channel. */ + int result; /* Of calling FlushChannel. */ + Channel *chanPtr = (Channel *) chan; /* The actual channel. */ + ChannelState *statePtr = chanPtr->state; /* State of actual channel. */ /* * This operation should occur at the top of a channel stack. @@ -6533,13 +5305,14 @@ Tcl_Flush( * Force current output buffer to be output also. */ - if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); + if ((statePtr->curOutPtr != NULL) + && (statePtr->curOutPtr->nextAdded > 0)) { + statePtr->flags |= BUFFER_READY; } - + result = FlushChannel(NULL, chanPtr, 0); if (result != 0) { - return TCL_ERROR; + return TCL_ERROR; } return TCL_OK; @@ -6550,8 +5323,8 @@ Tcl_Flush( * * DiscardInputQueued -- * - * Discards any input read from the channel but not yet consumed by Tcl - * reading commands. + * Discards any input read from the channel but not yet consumed + * by Tcl reading commands. * * Results: * None. @@ -6564,31 +5337,32 @@ Tcl_Flush( */ static void -DiscardInputQueued( - ChannelState *statePtr, /* Channel on which to discard the queued - * input. */ - int discardSavedBuffers) /* If non-zero, discard all buffers including - * last one. */ +DiscardInputQueued(statePtr, discardSavedBuffers) + ChannelState *statePtr; /* Channel on which to discard + * the queued input. */ + int discardSavedBuffers; /* If non-zero, discard all buffers including + * last one. */ { - ChannelBuffer *bufPtr, *nxtPtr; - /* Loop variables. */ + ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */ bufPtr = statePtr->inQueueHead; - statePtr->inQueueHead = NULL; - statePtr->inQueueTail = NULL; - for (; bufPtr != NULL; bufPtr = nxtPtr) { - nxtPtr = bufPtr->nextPtr; - RecycleBuffer(statePtr, bufPtr, discardSavedBuffers); + statePtr->inQueueHead = (ChannelBuffer *) NULL; + statePtr->inQueueTail = (ChannelBuffer *) NULL; + for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) { + nxtPtr = bufPtr->nextPtr; + RecycleBuffer(statePtr, bufPtr, discardSavedBuffers); } /* * If discardSavedBuffers is nonzero, must also discard any previously * saved buffer in the saveInBufPtr field. */ - - if (discardSavedBuffers && statePtr->saveInBufPtr != NULL) { - ckfree(statePtr->saveInBufPtr); - statePtr->saveInBufPtr = NULL; + + if (discardSavedBuffers) { + if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) { + ckfree((char *) statePtr->saveInBufPtr); + statePtr->saveInBufPtr = (ChannelBuffer *) NULL; + } } } @@ -6597,11 +5371,11 @@ DiscardInputQueued( * * GetInput -- * - * Reads input data from a device into a channel buffer. + * Reads input data from a device into a channel buffer. * * Results: * The return value is the Posix error code if an error occurred while - * reading from the file, or 0 otherwise. + * reading from the file, or 0 otherwise. * * Side effects: * Reads from the underlying device. @@ -6610,15 +5384,14 @@ DiscardInputQueued( */ static int -GetInput( - Channel *chanPtr) /* Channel to read input from. */ +GetInput(chanPtr) + Channel *chanPtr; /* Channel to read input from. */ { int toRead; /* How much to read? */ int result; /* Of calling driver. */ int nread; /* How much was read from channel? */ ChannelBuffer *bufPtr; /* New buffer to add to input queue. */ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* * Prevent reading from a dead channel -- a channel that has been closed @@ -6626,91 +5399,90 @@ GetInput( * channel cleanup has run but the channel is still registered in some * interpreter. */ - + if (CheckForDeadChannel(NULL, statePtr)) { return EINVAL; } /* - * First check for more buffers in the pushback area of the topmost - * channel in the stack and use them. They can be the result of a - * transformation which went away without reading all the information - * placed in the area when it was stacked. + * First check for more buffers in the pushback area of the + * topmost channel in the stack and use them. They can be the + * result of a transformation which went away without reading all + * the information placed in the area when it was stacked. * - * Two possibilities for the state: No buffers in it, or a single empty - * buffer. In the latter case we can recycle it now. + * Two possibilities for the state: No buffers in it, or a single + * empty buffer. In the latter case we can recycle it now. */ - if (chanPtr->inQueueHead != NULL) { - if (statePtr->inQueueHead != NULL) { + if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) { + if (statePtr->inQueueHead != (ChannelBuffer*) NULL) { RecycleBuffer(statePtr, statePtr->inQueueHead, 0); - statePtr->inQueueHead = NULL; + statePtr->inQueueHead = (ChannelBuffer*) NULL; } statePtr->inQueueHead = chanPtr->inQueueHead; statePtr->inQueueTail = chanPtr->inQueueTail; - chanPtr->inQueueHead = NULL; - chanPtr->inQueueTail = NULL; + chanPtr->inQueueHead = (ChannelBuffer*) NULL; + chanPtr->inQueueTail = (ChannelBuffer*) NULL; return 0; } /* - * Nothing in the pushback area, fall back to the usual handling (driver, - * etc.) + * Nothing in the pushback area, fall back to the usual handling + * (driver, etc.) */ /* - * See if we can fill an existing buffer. If we can, read only as much as - * will fit in it. Otherwise allocate a new buffer, add it to the input - * queue and attempt to fill it to the max. + * See if we can fill an existing buffer. If we can, read only + * as much as will fit in it. Otherwise allocate a new buffer, + * add it to the input queue and attempt to fill it to the max. */ bufPtr = statePtr->inQueueTail; - if ((bufPtr != NULL) && !IsBufferFull(bufPtr)) { - toRead = SpaceLeft(bufPtr); + if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) { + toRead = bufPtr->bufLength - bufPtr->nextAdded; } else { bufPtr = statePtr->saveInBufPtr; statePtr->saveInBufPtr = NULL; /* - * Check the actual buffersize against the requested buffersize. - * Buffers which are smaller than requested are squashed. This is done - * to honor dynamic changes of the buffersize made by the user. + * Check the actual buffersize against the requested + * buffersize. Buffers which are smaller than requested are + * squashed. This is done to honor dynamic changes of the + * buffersize made by the user. */ - if ((bufPtr != NULL) - && (bufPtr->bufLength - BUFFER_PADDING < statePtr->bufSize)) { - ckfree(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 = 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 size for new - * buffers. They can be different if the buffersize was changed - * between reads. + /* SF #427196: Use the actual size of the buffer to determine + * the number of bytes to read from the channel and not the + * size for new buffers. They can be different if the + * buffersize was changed between reads. * - * Note: This affects performance negatively if the buffersize was - * extended but this small buffer is reused for all subsequent reads. - * The system never uses buffers with the requested bigger size in - * that case. An adjunct patch could try and delete all unused buffers - * it encounters and which are smaller than the formally requested - * buffersize. + * Note: This affects performance negatively if the buffersize + * was extended but this small buffer is reused for all + * subsequent reads. The system never uses buffers with the + * requested bigger size in that case. An adjunct patch could + * try and delete all unused buffers it encounters and which + * are smaller than the formally requested buffersize. */ - toRead = SpaceLeft(bufPtr); + 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; } /* @@ -6718,62 +5490,62 @@ GetInput( * platforms it is impossible to read from a device after EOF. */ - if (GotFlag(statePtr, CHANNEL_EOF)) { + if (statePtr->flags & CHANNEL_EOF) { return 0; } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* - * [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. + /* [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 (GotFlag(statePtr, CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !GotFlag(statePtr, CHANNEL_HAS_MORE_DATA)) { - /* - * Bypass the driver, it would block, as no data is available - */ + if ((statePtr->flags & CHANNEL_NONBLOCKING) && + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { - nread = -1; - result = EWOULDBLOCK; - } else + /* 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 */ - { - nread = ChanRead(chanPtr, InsertPoint(bufPtr), 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 */ if (nread > 0) { bufPtr->nextAdded += nread; /* - * 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 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 < toRead) { - SetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags |= CHANNEL_BLOCKED; } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING if (nread <= toRead) { - /* - * [Bug 943274]: We have read the available data, clear flag. - */ - - ResetFlag(statePtr, 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 */ + } else if (nread == 0) { - SetFlag(statePtr, CHANNEL_EOF); + statePtr->flags |= CHANNEL_EOF; statePtr->inputEncodingFlags |= TCL_ENCODING_END; } else if (nread < 0) { if ((result == EWOULDBLOCK) || (result == EAGAIN)) { - SetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags |= CHANNEL_BLOCKED; result = EAGAIN; } Tcl_SetErrno(result); @@ -6787,12 +5559,12 @@ GetInput( * * Tcl_Seek -- * - * Implements seeking on Tcl Channels. This is a public function so that - * other C facilities may be implemented on top of it. + * Implements seeking on Tcl Channels. This is a public function + * so that other C facilities may be implemented on top of it. * * Results: - * The new access point or -1 on error. If error, use Tcl_GetErrno() to - * retrieve the POSIX error code for the error that occurred. + * The new access point or -1 on error. If error, use Tcl_GetErrno() + * to retrieve the POSIX error code for the error that occurred. * * Side effects: * May flush output on the channel. May discard queued input. @@ -6801,32 +5573,30 @@ GetInput( */ Tcl_WideInt -Tcl_Seek( - Tcl_Channel chan, /* The channel on which to seek. */ - Tcl_WideInt offset, /* Offset to seek to. */ - int mode) /* Relative to which location to seek? */ +Tcl_Seek(chan, offset, mode) + Tcl_Channel chan; /* The channel on which to seek. */ + Tcl_WideInt offset; /* Offset to seek to. */ + int mode; /* Relative to which location to seek? */ { - Channel *chanPtr = (Channel *) chan; - /* The real IO channel. */ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + Channel *chanPtr = (Channel *) chan; /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ int inputBuffered, outputBuffered; /* # bytes held in buffers. */ int result; /* Of device driver operations. */ Tcl_WideInt curPos; /* Position on the device. */ - int wasAsync; /* Was the channel nonblocking before the seek - * operation? If so, must restore to - * non-blocking mode after the seek. */ + int wasAsync; /* Was the channel nonblocking before the + * seek operation? If so, must restore to + * nonblocking mode after the seek. */ if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) { return Tcl_LongAsWide(-1); } /* - * Disallow seek on dead channels - channels that have been closed but not - * yet been deallocated. Such channels can be found if the exit handler - * for channel cleanup has run but the channel is still registered in an - * interpreter. + * Disallow seek on dead channels -- channels that have been closed but + * not yet been deallocated. Such channels can be found if the exit + * handler for channel cleanup has run but the channel is still + * registered in an interpreter. */ if (CheckForDeadChannel(NULL, statePtr)) { @@ -6844,22 +5614,22 @@ Tcl_Seek( * defined. This means that the channel does not support seeking. */ - if (chanPtr->typePtr->seekProc == NULL) { - Tcl_SetErrno(EINVAL); - return Tcl_LongAsWide(-1); + if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); } /* - * Compute how much input and output is buffered. If both input and output - * is buffered, cannot compute the current position. + * Compute how much input and output is buffered. If both input and + * output is buffered, cannot compute the current position. */ inputBuffered = Tcl_InputBuffered(chan); outputBuffered = Tcl_OutputBuffered(chan); if ((inputBuffered != 0) && (outputBuffered != 0)) { - Tcl_SetErrno(EFAULT); - return Tcl_LongAsWide(-1); + Tcl_SetErrno(EFAULT); + return Tcl_LongAsWide(-1); } /* @@ -6868,85 +5638,90 @@ Tcl_Seek( */ if (mode == SEEK_CUR) { - offset -= inputBuffered; + offset -= inputBuffered; } /* - * Discard any queued input - this input should not be read after the - * seek. + * Discard any queued input - this input should not be read after + * the seek. */ DiscardInputQueued(statePtr, 0); /* - * Reset EOF and BLOCKED flags. We invalidate them by moving the access - * point. Also clear CR related flags. + * Reset EOF and BLOCKED flags. We invalidate them by moving the + * access point. Also clear CR related flags. */ - ResetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | - INPUT_SAW_CR); - + statePtr->flags &= + (~(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 scheduled. - * After the flush, the channel will be put back into asynchronous output - * mode. + * If the channel is in asynchronous output mode, switch it back + * to synchronous mode and cancel any async flush that may be + * scheduled. After the flush, the channel will be put back into + * asynchronous output mode. */ wasAsync = 0; - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { - wasAsync = 1; - result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); + if (statePtr->flags & CHANNEL_NONBLOCKING) { + wasAsync = 1; + result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); if (result != 0) { return Tcl_LongAsWide(-1); } - ResetFlag(statePtr, CHANNEL_NONBLOCKING); - if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { - ResetFlag(statePtr, BG_FLUSH_SCHEDULED); - } - } - - /* - * If there is data buffered in statePtr->curOutPtr then mark the channel - * as ready to flush before invoking FlushChannel. - */ - - if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) { - SetFlag(statePtr, BUFFER_READY); + statePtr->flags &= (~(CHANNEL_NONBLOCKING)); + if (statePtr->flags & BG_FLUSH_SCHEDULED) { + statePtr->flags &= (~(BG_FLUSH_SCHEDULED)); + } } - + /* - * If the flush fails we cannot recover the original position. In that - * case the seek is not attempted because we do not know where the access - * position is - instead we return the error. FlushChannel has already - * called Tcl_SetErrno() to report the error upwards. If the flush - * succeeds we do the seek also. + * If the flush fails we cannot recover the original position. In + * that case the seek is not attempted because we do not know where + * the access position is - instead we return the error. FlushChannel + * has already called Tcl_SetErrno() to report the error upwards. + * If the flush succeeds we do the seek also. */ - + if (FlushChannel(NULL, chanPtr, 0) != 0) { - curPos = -1; + curPos = -1; } else { - /* - * Now seek to the new position in the channel as requested by the - * caller. - */ - curPos = ChanSeek(chanPtr, offset, mode, &result); + /* + * 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) { + curPos = (chanPtr->typePtr->wideSeekProc) (chanPtr->instanceData, + offset, mode, &result); + } else if (offset < Tcl_LongAsWide(LONG_MIN) || + offset > Tcl_LongAsWide(LONG_MAX)) { + result = EOVERFLOW; + curPos = Tcl_LongAsWide(-1); + } else { + curPos = Tcl_LongAsWide((chanPtr->typePtr->seekProc) ( + chanPtr->instanceData, Tcl_WideAsLong(offset), mode, + &result)); + } if (curPos == Tcl_LongAsWide(-1)) { Tcl_SetErrno(result); } } - + /* * Restore to nonblocking mode if that was the previous behavior. * - * NOTE: Even if there was an async flush active we do not restore it now - * because we already flushed all the queued output, above. + * NOTE: Even if there was an async flush active we do not restore + * it now because we already flushed all the queued output, above. */ - + if (wasAsync) { - SetFlag(statePtr, CHANNEL_NONBLOCKING); - result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); + statePtr->flags |= CHANNEL_NONBLOCKING; + result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); if (result != 0) { return Tcl_LongAsWide(-1); } @@ -6960,13 +5735,13 @@ Tcl_Seek( * * Tcl_Tell -- * - * Returns the position of the next character to be read/written on this - * channel. + * Returns the position of the next character to be read/written on + * this channel. * * Results: - * A nonnegative integer on success, -1 on failure. If failed, use - * Tcl_GetErrno() to retrieve the POSIX error code for the error that - * occurred. + * A nonnegative integer on success, -1 on failure. If failed, + * use Tcl_GetErrno() to retrieve the POSIX error code for the + * error that occurred. * * Side effects: * None. @@ -6975,17 +5750,14 @@ Tcl_Seek( */ Tcl_WideInt -Tcl_Tell( - Tcl_Channel chan) /* The channel to return pos for. */ +Tcl_Tell(chan) + Tcl_Channel chan; /* The channel to return pos for. */ { - Channel *chanPtr = (Channel *) chan; - /* The real IO channel. */ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - int inputBuffered, outputBuffered; - /* # bytes held in buffers. */ - int result; /* Of calling device driver. */ - Tcl_WideInt curPos; /* Position on device. */ + Channel *chanPtr = (Channel *) chan; /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ + int inputBuffered, outputBuffered; /* # bytes held in buffers. */ + int result; /* Of calling device driver. */ + Tcl_WideInt curPos; /* Position on device. */ if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) { return Tcl_LongAsWide(-1); @@ -6994,8 +5766,8 @@ Tcl_Tell( /* * Disallow tell on dead channels -- channels that have been closed but * not yet been deallocated. Such channels can be found if the exit - * handler for channel cleanup has run but the channel is still registered - * in an interpreter. + * handler for channel cleanup has run but the channel is still + * registered in an interpreter. */ if (CheckForDeadChannel(NULL, statePtr)) { @@ -7013,33 +5785,44 @@ Tcl_Tell( * defined. This means that the channel does not support seeking. */ - if (chanPtr->typePtr->seekProc == NULL) { - Tcl_SetErrno(EINVAL); - return Tcl_LongAsWide(-1); + if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); } /* - * Compute how much input and output is buffered. If both input and output - * is buffered, cannot compute the current position. + * Compute how much input and output is buffered. If both input and + * output is buffered, cannot compute the current position. */ inputBuffered = Tcl_InputBuffered(chan); outputBuffered = Tcl_OutputBuffered(chan); + if ((inputBuffered != 0) && (outputBuffered != 0)) { + Tcl_SetErrno(EFAULT); + return Tcl_LongAsWide(-1); + } + /* - * Get the current position in the device and compute the position where - * the next character will be read or written. Note that we prefer the - * wideSeekProc if that is available and non-NULL... + * Get the current position in the device and compute the position + * where the next character will be read or written. Note that we + * prefer the wideSeekProc if that is available and non-NULL... */ - curPos = ChanSeek(chanPtr, Tcl_LongAsWide(0), SEEK_CUR, &result); + if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && + chanPtr->typePtr->wideSeekProc != NULL) { + curPos = (chanPtr->typePtr->wideSeekProc) (chanPtr->instanceData, + Tcl_LongAsWide(0), SEEK_CUR, &result); + } else { + curPos = Tcl_LongAsWide((chanPtr->typePtr->seekProc) ( + 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; } @@ -7049,9 +5832,9 @@ Tcl_Tell( * * Tcl_SeekOld, Tcl_TellOld -- * - * Backward-compatability versions of the seek/tell interface that do not - * support 64-bit offsets. This interface is not documented or expected - * to be supported indefinitely. + * Backward-compatability versions of the seek/tell interface that + * do not support 64-bit offsets. This interface is not documented + * or expected to be supported indefinitely. * * Results: * As for Tcl_Seek and Tcl_Tell respectively, except truncated to @@ -7064,97 +5847,26 @@ Tcl_Tell( */ int -Tcl_SeekOld( - Tcl_Channel chan, /* The channel on which to seek. */ - int offset, /* Offset to seek to. */ - int mode) /* Relative to which location to seek? */ +Tcl_SeekOld(chan, offset, mode) + Tcl_Channel chan; /* The channel on which to seek. */ + int offset; /* Offset to seek to. */ + int mode; /* Relative to which location to seek? */ { Tcl_WideInt wOffset, wResult; - wOffset = Tcl_LongAsWide((long) offset); + wOffset = Tcl_LongAsWide((long)offset); wResult = Tcl_Seek(chan, wOffset, mode); - return (int) Tcl_WideAsLong(wResult); + return (int)Tcl_WideAsLong(wResult); } int -Tcl_TellOld( - Tcl_Channel chan) /* The channel to return pos for. */ +Tcl_TellOld(chan) + Tcl_Channel chan; /* The channel to return pos for. */ { - Tcl_WideInt wResult = Tcl_Tell(chan); + Tcl_WideInt wResult; - return (int) Tcl_WideAsLong(wResult); -} - -/* - *--------------------------------------------------------------------------- - * - * Tcl_TruncateChannel -- - * - * Truncate a channel to the given length. - * - * Results: - * TCL_OK on success, TCL_ERROR if the operation failed (e.g. is not - * supported by the type of channel, or the underlying OS operation - * failed in some way). - * - * Side effects: - * Seeks the channel to the current location. Sets errno on OS error. - * - *--------------------------------------------------------------------------- - */ - -int -Tcl_TruncateChannel( - Tcl_Channel chan, /* Channel to truncate. */ - Tcl_WideInt length) /* Length to truncate it to. */ -{ - Channel *chanPtr = (Channel *) chan; - Tcl_DriverTruncateProc *truncateProc = - Tcl_ChannelTruncateProc(chanPtr->typePtr); - int result; - - if (truncateProc == NULL) { - /* - * Feature not supported and it's not emulatable. Pretend it's - * returned an EINVAL, a very generic error! - */ - - Tcl_SetErrno(EINVAL); - return TCL_ERROR; - } - - if (!GotFlag(chanPtr->state, TCL_WRITABLE)) { - /* - * We require that the file was opened of writing. Do that check now - * so that we only flush if we think we're going to succeed. - */ - - Tcl_SetErrno(EINVAL); - return TCL_ERROR; - } - - /* - * Seek first to force a total flush of all pending buffers and ditch any - * pre-read input data. - */ - - WillWrite(chanPtr); - - if (WillRead(chanPtr) < 0) { - return TCL_ERROR; - } - - /* - * We're all flushed to disk now and we also don't have any unfortunate - * input baggage around either; can truncate with impunity. - */ - - result = truncateProc(chanPtr->instanceData, length); - if (result != 0) { - Tcl_SetErrno(result); - return TCL_ERROR; - } - return TCL_OK; + wResult = Tcl_Tell(chan); + return (int)Tcl_WideAsLong(wResult); } /* @@ -7162,26 +5874,26 @@ Tcl_TruncateChannel( * * CheckChannelErrors -- * - * See if the channel is in an ready state and can perform the desired - * operation. + * See if the channel is in an ready state and can perform the + * desired operation. * * Results: - * The return value is 0 if the channel is OK, otherwise the return value - * is -1 and errno is set to indicate the error. + * The return value is 0 if the channel is OK, otherwise the + * return value is -1 and errno is set to indicate the error. * * Side effects: * May clear the EOF and/or BLOCKED bits if reading from channel. * *--------------------------------------------------------------------------- */ - + static int -CheckChannelErrors( - ChannelState *statePtr, /* Channel to check. */ - int flags) /* Test if channel supports desired operation: - * TCL_READABLE, TCL_WRITABLE. Also indicates +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); @@ -7190,30 +5902,20 @@ CheckChannelErrors( */ if (statePtr->unreportedError != 0) { - Tcl_SetErrno(statePtr->unreportedError); - statePtr->unreportedError = 0; - - /* - * TIP #219, Tcl Channel Reflection API. - * Move a defered error message back into the channel bypass. - */ - - if (statePtr->chanMsg != NULL) { - TclDecrRefCount(statePtr->chanMsg); - } - statePtr->chanMsg = statePtr->unreportedMsg; - statePtr->unreportedMsg = NULL; - return -1; + Tcl_SetErrno(statePtr->unreportedError); + statePtr->unreportedError = 0; + return -1; } /* - * Only the raw read and write operations are allowed during close in - * order to drain data from stacked channels. + * Only the raw read and write operations are allowed during close + * in order to drain data from stacked channels. */ - if (GotFlag(statePtr, CHANNEL_CLOSED) && !(flags & CHANNEL_RAW_MODE)) { - Tcl_SetErrno(EACCES); - return -1; + if ((statePtr->flags & CHANNEL_CLOSED) && + ((flags & CHANNEL_RAW_MODE) == 0)) { + Tcl_SetErrno(EACCES); + return -1; } /* @@ -7221,8 +5923,8 @@ CheckChannelErrors( */ if ((statePtr->flags & direction) == 0) { - Tcl_SetErrno(EACCES); - return -1; + Tcl_SetErrno(EACCES); + return -1; } /* @@ -7233,23 +5935,23 @@ CheckChannelErrors( * retrieving and transforming the data to copy. */ - if (BUSY_STATE(statePtr, flags) && ((flags & CHANNEL_RAW_MODE) == 0)) { + if (BUSY_STATE(statePtr,flags) && ((flags & CHANNEL_RAW_MODE) == 0)) { Tcl_SetErrno(EBUSY); return -1; } if (direction == TCL_READABLE) { /* - * If we have not encountered a sticky EOF, clear the EOF bit (sticky - * EOF is set if we have seen the input eofChar, to prevent reading - * beyond the eofChar). Also, always clear the BLOCKED bit. We want to - * discover these conditions anew in each operation. + * If we have not encountered a sticky EOF, clear the EOF bit + * (sticky EOF is set if we have seen the input eofChar, to prevent + * reading beyond the eofChar). Also, always clear the BLOCKED bit. + * We want to discover these conditions anew in each operation. */ - if (!GotFlag(statePtr, CHANNEL_STICKY_EOF)) { - ResetFlag(statePtr, CHANNEL_EOF); + if ((statePtr->flags & CHANNEL_STICKY_EOF) == 0) { + statePtr->flags &= ~CHANNEL_EOF; } - ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA); + statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA); } return 0; @@ -7272,15 +5974,15 @@ CheckChannelErrors( */ int -Tcl_Eof( - Tcl_Channel chan) /* Does this channel have EOF? */ +Tcl_Eof(chan) + Tcl_Channel chan; /* Does this channel have EOF? */ { ChannelState *statePtr = ((Channel *) chan)->state; - /* State of real channel structure. */ + /* State of real channel structure. */ - return (GotFlag(statePtr, CHANNEL_STICKY_EOF) || - (GotFlag(statePtr, CHANNEL_EOF) && - (Tcl_InputBuffered(chan) == 0))) ? 1 : 0; + return ((statePtr->flags & CHANNEL_STICKY_EOF) || + ((statePtr->flags & CHANNEL_EOF) && + (Tcl_InputBuffered(chan) == 0))) ? 1 : 0; } /* @@ -7300,13 +6002,13 @@ Tcl_Eof( */ int -Tcl_InputBlocked( - Tcl_Channel chan) /* Is this channel blocked? */ +Tcl_InputBlocked(chan) + Tcl_Channel chan; /* Is this channel blocked? */ { ChannelState *statePtr = ((Channel *) chan)->state; - /* State of real channel structure. */ + /* State of real channel structure. */ - return GotFlag(statePtr, CHANNEL_BLOCKED) ? 1 : 0; + return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0; } /* @@ -7314,12 +6016,12 @@ Tcl_InputBlocked( * * Tcl_InputBuffered -- * - * Returns the number of bytes of input currently buffered in the common - * internal buffer of a channel. + * Returns the number of bytes of input currently buffered in the + * common internal buffer of a channel. * * Results: - * The number of input bytes buffered, or zero if the channel is not open - * for reading. + * The number of input bytes buffered, or zero if the channel is not + * open for reading. * * Side effects: * None. @@ -7328,26 +6030,28 @@ Tcl_InputBlocked( */ int -Tcl_InputBuffered( - Tcl_Channel chan) /* The channel to query. */ +Tcl_InputBuffered(chan) + 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; - for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; bufPtr != NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += BytesLeft(bufPtr); + for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } /* * Don't forget the bytes in the topmost pushback area. */ - for (bufPtr = statePtr->topChanPtr->inQueueHead; bufPtr != NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += BytesLeft(bufPtr); + for (bufPtr = statePtr->topChanPtr->inQueueHead; + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } return bytesBuffered; @@ -7358,12 +6062,12 @@ Tcl_InputBuffered( * * Tcl_OutputBuffered -- * - * Returns the number of bytes of output currently buffered in the common - * internal buffer of a channel. + * Returns the number of bytes of output currently buffered in the + * common internal buffer of a channel. * * Results: - * The number of output bytes buffered, or zero if the channel is not open - * for writing. + * The number of output bytes buffered, or zero if the channel is not + * open for writing. * * Side effects: * None. @@ -7372,24 +6076,24 @@ Tcl_InputBuffered( */ int -Tcl_OutputBuffered( - Tcl_Channel chan) /* The channel to query. */ +Tcl_OutputBuffered(chan) + 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; - for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += BytesLeft(bufPtr); + for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } - if (statePtr->curOutPtr != NULL) { - register ChannelBuffer *curOutPtr = statePtr->curOutPtr; - - if (IsBufferReady(curOutPtr)) { - bytesBuffered += BytesLeft(curOutPtr); - } + if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) && + (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) { + statePtr->flags |= BUFFER_READY; + bytesBuffered += + (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved); } return bytesBuffered; @@ -7404,8 +6108,8 @@ Tcl_OutputBuffered( * internal buffer (push back area) of a channel. * * Results: - * The number of input bytes buffered, or zero if the channel is not open - * for reading. + * The number of input bytes buffered, or zero if the channel is not + * open for reading. * * Side effects: * None. @@ -7414,17 +6118,18 @@ Tcl_OutputBuffered( */ int -Tcl_ChannelBuffered( - Tcl_Channel chan) /* The channel to query. */ +Tcl_ChannelBuffered(chan) + Tcl_Channel chan; /* The channel to query. */ { Channel *chanPtr = (Channel *) chan; - /* Real channel structure. */ + /* real channel structure. */ ChannelBuffer *bufPtr; - int bytesBuffered = 0; + int bytesBuffered; - for (bufPtr = chanPtr->inQueueHead; bufPtr != NULL; - bufPtr = bufPtr->nextPtr) { - bytesBuffered += BytesLeft(bufPtr); + for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead; + bufPtr != (ChannelBuffer *) NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); } return bytesBuffered; @@ -7435,8 +6140,8 @@ Tcl_ChannelBuffered( * * Tcl_SetChannelBufferSize -- * - * Sets the size of buffers to allocate to store input or output in the - * channel. The size must be between 1 byte and 1 MByte. + * Sets the size of buffers to allocate to store input or output + * in the channel. The size must be between 1 byte and 1 MByte. * * Results: * None. @@ -7448,31 +6153,33 @@ Tcl_ChannelBuffered( */ void -Tcl_SetChannelBufferSize( - Tcl_Channel chan, /* The channel whose buffer size to set. */ - int sz) /* The size to set. */ +Tcl_SetChannelBufferSize(chan, sz) + Tcl_Channel chan; /* The channel whose buffer size + * to set. */ + int sz; /* The size to set. */ { - ChannelState *statePtr; /* State of real channel structure. */ - + ChannelState *statePtr; /* State of real channel structure. */ + /* * Clip the buffer size to force it into the [1,1M] range */ if (sz < 1) { - sz = 1; + sz = 1; } else if (sz > MAX_CHANNEL_BUFFER_SIZE) { - sz = MAX_CHANNEL_BUFFER_SIZE; + sz = MAX_CHANNEL_BUFFER_SIZE; } statePtr = ((Channel *) chan)->state; statePtr->bufSize = sz; if (statePtr->outputStage != NULL) { - ckfree(statePtr->outputStage); + ckfree((char *) statePtr->outputStage); statePtr->outputStage = NULL; } - if ((statePtr->encoding != NULL) && GotFlag(statePtr, TCL_WRITABLE)) { - statePtr->outputStage = ckalloc(statePtr->bufSize + 2); + if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { + statePtr->outputStage = (char *) + ckalloc((unsigned) (statePtr->bufSize + 2)); } } @@ -7493,12 +6200,12 @@ Tcl_SetChannelBufferSize( */ int -Tcl_GetChannelBufferSize( - Tcl_Channel chan) /* The channel for which to find the buffer - * size. */ +Tcl_GetChannelBufferSize(chan) + Tcl_Channel chan; /* The channel for which to find the + * buffer size. */ { ChannelState *statePtr = ((Channel *) chan)->state; - /* State of real channel structure. */ + /* State of real channel structure. */ return statePtr->bufSize; } @@ -7508,43 +6215,44 @@ Tcl_GetChannelBufferSize( * * Tcl_BadChannelOption -- * - * This procedure generates a "bad option" error message in an (optional) - * interpreter. It is used by channel drivers when a invalid Set/Get - * option is requested. Its purpose is to concatenate the generic options - * list to the specific ones and factorize the generic options error - * message string. + * This procedure generates a "bad option" error message in an + * (optional) interpreter. It is used by channel drivers when + * a invalid Set/Get option is requested. Its purpose is to concatenate + * the generic options list to the specific ones and factorize + * the generic options error message string. * * Results: * TCL_ERROR. * * Side effects: - - * An error message is generated in interp's result object to indicate - * that a command was invoked with the a bad option. The message has the - * form: - * bad option "blah": should be one of - * <...generic options...>+<...specific options...> - * "blah" is the optionName argument and "<specific options>" is a space - * separated list of specific option words. The function takes good care - * of inserting minus signs before each option, commas after, and an "or" - * before the last option. + * An error message is generated in interp's result object to + * indicate that a command was invoked with the a bad option + * The message has the form + * bad option "blah": should be one of + * <...generic options...>+<...specific options...> + * "blah" is the optionName argument and "<specific options>" + * is a space separated list of specific option words. + * The function takes good care of inserting minus signs before + * each option, commas after, and an "or" before the last option. * *---------------------------------------------------------------------- */ int -Tcl_BadChannelOption( - Tcl_Interp *interp, /* Current interpreter (can be NULL).*/ - const char *optionName, /* 'bad option' name */ - const char *optionList) /* Specific options list to append to the - * standard generic options. Can be NULL for - * generic options only. */ +Tcl_BadChannelOption(interp, optionName, optionList) + Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/ + CONST char *optionName; /* 'bad option' name */ + CONST char *optionList; /* Specific options list to append + * to the standard generic options. + * can be NULL for generic options + * only. + */ { - if (interp != NULL) { - const char *genericopt = - "blocking buffering buffersize encoding eofchar translation"; - const char **argv; - int argc, i; + if (interp) { + CONST char *genericopt = + "blocking buffering buffersize encoding eofchar translation"; + CONST char **argv; + int argc, i; Tcl_DString ds; Tcl_DStringInit(&ds); @@ -7553,20 +6261,20 @@ Tcl_BadChannelOption( Tcl_DStringAppend(&ds, " ", 1); Tcl_DStringAppend(&ds, optionList, -1); } - if (Tcl_SplitList(interp, Tcl_DStringValue(&ds), + if (Tcl_SplitList(interp, Tcl_DStringValue(&ds), &argc, &argv) != TCL_OK) { - Tcl_Panic("malformed option list in channel driver"); + panic("malformed option list in channel driver"); } Tcl_ResetResult(interp); - Tcl_AppendResult(interp, "bad option \"", optionName, - "\": should be one of ", NULL); + Tcl_AppendResult(interp, "bad option \"", optionName, + "\": should be one of ", (char *) NULL); argc--; for (i = 0; i < argc; i++) { - Tcl_AppendResult(interp, "-", argv[i], ", ", NULL); + Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL); } - Tcl_AppendResult(interp, "or -", argv[i], NULL); + Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL); Tcl_DStringFree(&ds); - ckfree(argv); + ckfree((char *) argv); } Tcl_SetErrno(EINVAL); return TCL_ERROR; @@ -7577,40 +6285,39 @@ Tcl_BadChannelOption( * * Tcl_GetChannelOption -- * - * Gets a mode associated with an IO channel. If the optionName arg is - * non NULL, retrieves the value of that option. If the optionName arg is - * NULL, retrieves a list of alternating option names and values for the - * given channel. + * Gets a mode associated with an IO channel. If the optionName arg + * is non NULL, retrieves the value of that option. If the optionName + * arg is NULL, retrieves a list of alternating option names and + * values for the given channel. * * Results: - * A standard Tcl result. Also sets the supplied DString to the string - * value of the option(s) returned. + * A standard Tcl result. Also sets the supplied DString to the + * string value of the option(s) returned. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ int -Tcl_GetChannelOption( - Tcl_Interp *interp, /* For error reporting - can be NULL. */ - Tcl_Channel chan, /* Channel on which to get option. */ - const char *optionName, /* Option to get. */ - Tcl_DString *dsPtr) /* Where to store value(s). */ +Tcl_GetChannelOption(interp, chan, optionName, dsPtr) + Tcl_Interp *interp; /* For error reporting - can be NULL. */ + Tcl_Channel chan; /* Channel on which to get option. */ + CONST char *optionName; /* Option to get. */ + Tcl_DString *dsPtr; /* Where to store value(s). */ { size_t len; /* Length of optionName string. */ char optionVal[128]; /* Buffer for sprintf. */ Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ int flags; /* * Disallow options on dead channels -- channels that have been closed but * not yet been deallocated. Such channels can be found if the exit - * handler for channel cleanup has run but the channel is still registered - * in an interpreter. + * handler for channel cleanup has run but the channel is still + * registered in an interpreter. */ if (CheckForDeadChannel(interp, statePtr)) { @@ -7628,60 +6335,65 @@ Tcl_GetChannelOption( */ if (statePtr->csPtrR) { - flags = statePtr->csPtrR->readFlags; + flags = statePtr->csPtrR->readFlags; } else if (statePtr->csPtrW) { - flags = statePtr->csPtrW->writeFlags; + flags = statePtr->csPtrW->writeFlags; } else { flags = statePtr->flags; } /* - * If the optionName is NULL it means that we want a list of all options - * and values. + * If the optionName is NULL it means that we want a list of all + * options and values. */ - - if (optionName == NULL) { - len = 0; + + if (optionName == (char *) NULL) { + len = 0; } else { - len = strlen(optionName); + len = strlen(optionName); } - - if (len == 0 || HaveOpt(2, "-blocking")) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-blocking"); - } - Tcl_DStringAppendElement(dsPtr, + + if ((len == 0) || ((len > 2) && (optionName[1] == 'b') && + (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 || HaveOpt(7, "-buffering")) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-buffering"); - } - if (flags & CHANNEL_LINEBUFFERED) { - Tcl_DStringAppendElement(dsPtr, "line"); - } else if (flags & CHANNEL_UNBUFFERED) { - Tcl_DStringAppendElement(dsPtr, "none"); - } else { - Tcl_DStringAppendElement(dsPtr, "full"); - } - if (len > 0) { - return TCL_OK; - } + if ((len == 0) || ((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; + } } - if (len == 0 || HaveOpt(7, "-buffersize")) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-buffersize"); - } - TclFormatInt(optionVal, statePtr->bufSize); - Tcl_DStringAppendElement(dsPtr, optionVal); - if (len > 0) { - return TCL_OK; - } + if ((len == 0) || ((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 || HaveOpt(2, "-encoding")) { + if ((len == 0) || + ((len > 2) && (optionName[1] == 'e') && + (strncmp(optionName, "-encoding", len) == 0))) { if (len == 0) { Tcl_DStringAppendElement(dsPtr, "-encoding"); } @@ -7695,111 +6407,108 @@ Tcl_GetChannelOption( return TCL_OK; } } - if (len == 0 || HaveOpt(2, "-eofchar")) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-eofchar"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringStartSublist(dsPtr); - } - if (flags & TCL_READABLE) { - if (statePtr->inEofChar == 0) { - Tcl_DStringAppendElement(dsPtr, ""); - } else { - char buf[4]; - - sprintf(buf, "%c", statePtr->inEofChar); - Tcl_DStringAppendElement(dsPtr, buf); - } - } - if (flags & TCL_WRITABLE) { - if (statePtr->outEofChar == 0) { - Tcl_DStringAppendElement(dsPtr, ""); - } else { - char buf[4]; - - sprintf(buf, "%c", statePtr->outEofChar); - Tcl_DStringAppendElement(dsPtr, buf); - } - } - if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { - /* - * Not readable or writable (e.g. server socket) - */ - - Tcl_DStringAppendElement(dsPtr, ""); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringEndSublist(dsPtr); - } - if (len > 0) { - return TCL_OK; - } + if ((len == 0) || + ((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 || HaveOpt(1, "-translation")) { - if (len == 0) { - Tcl_DStringAppendElement(dsPtr, "-translation"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringStartSublist(dsPtr); - } - if (flags & TCL_READABLE) { - if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) { - Tcl_DStringAppendElement(dsPtr, "auto"); - } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) { - Tcl_DStringAppendElement(dsPtr, "cr"); - } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) { - Tcl_DStringAppendElement(dsPtr, "crlf"); - } else { - Tcl_DStringAppendElement(dsPtr, "lf"); - } - } - if (flags & TCL_WRITABLE) { - if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) { - Tcl_DStringAppendElement(dsPtr, "auto"); - } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) { - Tcl_DStringAppendElement(dsPtr, "cr"); - } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) { - Tcl_DStringAppendElement(dsPtr, "crlf"); - } else { - Tcl_DStringAppendElement(dsPtr, "lf"); - } - } - if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { - /* - * Not readable or writable (e.g. server socket) - */ - - Tcl_DStringAppendElement(dsPtr, "auto"); - } - if (((flags & (TCL_READABLE|TCL_WRITABLE)) == - (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { - Tcl_DStringEndSublist(dsPtr); - } - if (len > 0) { - return TCL_OK; - } + if ((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 (chanPtr->typePtr->getOptionProc != NULL) { + if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) { /* - * Let the driver specific handle additional options and result code - * and message. + * let the driver specific handle additional options + * and result code and message. */ - return chanPtr->typePtr->getOptionProc(chanPtr->instanceData, interp, - optionName, dsPtr); + return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData, + interp, optionName, dsPtr); } else { /* - * No driver specific options case. + * no driver specific options case. */ - if (len == 0) { - return TCL_OK; - } + if (len == 0) { + return TCL_OK; + } return Tcl_BadChannelOption(interp, optionName, NULL); } } @@ -7812,8 +6521,8 @@ Tcl_GetChannelOption( * Sets an option on a channel. * * Results: - * A standard Tcl result. On error, sets interp's result object if - * interp is not NULL. + * A standard Tcl result. On error, sets interp's result object + * if interp is not NULL. * * Side effects: * May modify an option on a device. @@ -7822,19 +6531,17 @@ Tcl_GetChannelOption( */ int -Tcl_SetChannelOption( - Tcl_Interp *interp, /* For error reporting - can be NULL. */ - Tcl_Channel chan, /* Channel on which to set mode. */ - const char *optionName, /* Which option to set? */ - const char *newValue) /* New value for option. */ -{ - Channel *chanPtr = (Channel *) chan; - /* The real IO channel. */ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ +Tcl_SetChannelOption(interp, chan, optionName, newValue) + Tcl_Interp *interp; /* For error reporting - can be NULL. */ + Tcl_Channel chan; /* Channel on which to set mode. */ + CONST char *optionName; /* Which option to set? */ + CONST char *newValue; /* New value for option. */ +{ + Channel *chanPtr = (Channel *) chan; /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ size_t len; /* Length of optionName string. */ int argc; - const char **argv; + CONST char **argv; /* * If the channel is in the middle of a background copy, fail. @@ -7842,17 +6549,18 @@ Tcl_SetChannelOption( if (statePtr->csPtrR || statePtr->csPtrW) { if (interp) { - Tcl_AppendResult(interp, "unable to set channel options: " - "background copy in progress", NULL); + Tcl_AppendResult(interp, + "unable to set channel options: background copy in progress", + (char *) NULL); } - return TCL_ERROR; + return TCL_ERROR; } /* * Disallow options on dead channels -- channels that have been closed but * not yet been deallocated. Such channels can be found if the exit - * handler for channel cleanup has run but the channel is still registered - * in an interpreter. + * handler for channel cleanup has run but the channel is still + * registered in an interpreter. */ if (CheckForDeadChannel(NULL, statePtr)) { @@ -7867,44 +6575,50 @@ Tcl_SetChannelOption( len = strlen(optionName); - if (HaveOpt(2, "-blocking")) { + if ((len > 2) && (optionName[1] == 'b') && + (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; - } - return SetBlockMode(interp, chanPtr, newMode); - } else if (HaveOpt(7, "-buffering")) { - len = strlen(newValue); - if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) { - ResetFlag(statePtr, CHANNEL_UNBUFFERED | CHANNEL_LINEBUFFERED); - } else if ((newValue[0] == 'l') && - (strncmp(newValue, "line", len) == 0)) { - ResetFlag(statePtr, CHANNEL_UNBUFFERED); - SetFlag(statePtr, CHANNEL_LINEBUFFERED); - } else if ((newValue[0] == 'n') && - (strncmp(newValue, "none", len) == 0)) { - ResetFlag(statePtr, CHANNEL_LINEBUFFERED); - SetFlag(statePtr, CHANNEL_UNBUFFERED); - } else if (interp) { - Tcl_AppendResult(interp, "bad value for -buffering: " - "must be one of full, line, or none", NULL); + 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; + } + } return TCL_OK; - } else if (HaveOpt(7, "-buffersize")) { + } else if ((len > 7) && (optionName[1] == 'b') && + (strncmp(optionName, "-buffersize", len) == 0)) { int newBufferSize; - if (Tcl_GetInt(interp, newValue, &newBufferSize) == TCL_ERROR) { return TCL_ERROR; } Tcl_SetChannelBufferSize(chan, newBufferSize); - } else if (HaveOpt(2, "-encoding")) { + } else if ((len > 2) && (optionName[1] == 'e') && + (strncmp(optionName, "-encoding", len) == 0)) { Tcl_Encoding encoding; if ((newValue[0] == '\0') || (strcmp(newValue, "binary") == 0)) { @@ -7915,12 +6629,10 @@ Tcl_SetChannelOption( 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; @@ -7932,81 +6644,78 @@ Tcl_SetChannelOption( statePtr->inputEncodingFlags = TCL_ENCODING_START; statePtr->outputEncodingState = NULL; statePtr->outputEncodingFlags = TCL_ENCODING_START; - ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + statePtr->flags &= ~CHANNEL_NEED_MORE_DATA; UpdateInterest(chanPtr); - } else if (HaveOpt(2, "-eofchar")) { - if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { - return TCL_ERROR; - } - if (argc == 0) { - statePtr->inEofChar = 0; - statePtr->outEofChar = 0; - } else if (argc == 1 || argc == 2) { - int outIndex = (argc - 1); - int inValue = (int) argv[0][0]; - int outValue = (int) argv[outIndex][0]; - - if (inValue & 0x80 || outValue & 0x80) { - if (interp) { - Tcl_AppendResult(interp, "bad value for -eofchar: ", - "must be non-NUL ASCII character", NULL); - } - ckfree(argv); - return TCL_ERROR; - } - if (GotFlag(statePtr, TCL_READABLE)) { - statePtr->inEofChar = inValue; - } - if (GotFlag(statePtr, TCL_WRITABLE)) { - statePtr->outEofChar = outValue; - } - } else { - if (interp) { - Tcl_AppendResult(interp, - "bad value for -eofchar: should be a list of zero," - " one, or two elements", NULL); - } - ckfree(argv); - return TCL_ERROR; - } - if (argv != NULL) { - ckfree(argv); - } + } 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); + } /* - * [Bug 930851] Reset EOF and BLOCKED flags. Changing the character - * which signals eof can transform a current eof condition into a 'go - * ahead'. Ditto for blocked. + * [SF Tcl Bug 930851] Reset EOF and BLOCKED flags. Changing + * the character which signals eof can transform a current eof + * condition into a 'go ahead'. Ditto for blocked. */ - ResetFlag(statePtr, CHANNEL_EOF|CHANNEL_STICKY_EOF|CHANNEL_BLOCKED); + statePtr->flags &= (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED)); + return TCL_OK; - } else if (HaveOpt(1, "-translation")) { - const char *readMode, *writeMode; + } else if ((len > 1) && (optionName[1] == 't') && + (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) { - readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL; - writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[0] : NULL; + if (argc == 1) { + readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL; + writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL; } else if (argc == 2) { - readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL; - writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[1] : NULL; + 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", NULL); - } - ckfree(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) { TclEolTranslation translation; - if (*readMode == '\0') { translation = statePtr->inputTranslation; } else if (strcmp(readMode, "auto") == 0) { @@ -8014,7 +6723,7 @@ Tcl_SetChannelOption( } else if (strcmp(readMode, "binary") == 0) { translation = TCL_TRANSLATE_LF; statePtr->inEofChar = 0; - Tcl_FreeEncoding(statePtr->encoding); + Tcl_FreeEncoding(statePtr->encoding); statePtr->encoding = NULL; } else if (strcmp(readMode, "lf") == 0) { translation = TCL_TRANSLATE_LF; @@ -8027,23 +6736,24 @@ Tcl_SetChannelOption( } else { if (interp) { Tcl_AppendResult(interp, - "bad value for -translation: " - "must be one of auto, binary, cr, lf, crlf," - " or platform", NULL); + "bad value for -translation: ", + "must be one of auto, binary, cr, lf, crlf,", + " or platform", (char *) NULL); } - ckfree(argv); + ckfree((char *) argv); return TCL_ERROR; } /* - * Reset the EOL flags since we need to look at any buffered data - * to see if the new translation mode allows us to complete the - * line. + * Reset the EOL flags since we need to look at any buffered + * data to see if the new translation mode allows us to + * complete the line. */ if (translation != statePtr->inputTranslation) { statePtr->inputTranslation = translation; - ResetFlag(statePtr, INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA); + statePtr->flags &= ~(INPUT_SAW_CR); + statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA); UpdateInterest(chanPtr); } } @@ -8052,9 +6762,10 @@ Tcl_SetChannelOption( /* Do nothing. */ } else if (strcmp(writeMode, "auto") == 0) { /* - * This is a hack to get TCP sockets to produce output in CRLF - * mode if they are being set into AUTO mode. A better - * solution for achieving this effect will be coded later. + * This is a hack to get TCP sockets to produce output + * in CRLF mode if they are being set into AUTO mode. + * A better solution for achieving this effect will be + * coded later. */ if (strcmp(Tcl_ChannelName(chanPtr->typePtr), "tcp") == 0) { @@ -8065,7 +6776,7 @@ Tcl_SetChannelOption( } else if (strcmp(writeMode, "binary") == 0) { statePtr->outEofChar = 0; statePtr->outputTranslation = TCL_TRANSLATE_LF; - Tcl_FreeEncoding(statePtr->encoding); + Tcl_FreeEncoding(statePtr->encoding); statePtr->encoding = NULL; } else if (strcmp(writeMode, "lf") == 0) { statePtr->outputTranslation = TCL_TRANSLATE_LF; @@ -8078,21 +6789,21 @@ Tcl_SetChannelOption( } else { if (interp) { Tcl_AppendResult(interp, - "bad value for -translation: " - "must be one of auto, binary, cr, lf, crlf," - " or platform", NULL); + "bad value for -translation: ", + "must be one of auto, binary, cr, lf, crlf,", + " or platform", (char *) NULL); } - ckfree(argv); + ckfree((char *) argv); return TCL_ERROR; } } - ckfree(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, NULL); + return Tcl_BadChannelOption(interp, optionName, (char *) NULL); } /* @@ -8103,12 +6814,14 @@ Tcl_SetChannelOption( RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1); statePtr->saveInBufPtr = NULL; } - if ((statePtr->inQueueHead != NULL) - && (statePtr->inQueueHead->nextPtr == NULL) - && IsBufferEmpty(statePtr->inQueueHead)) { - RecycleBuffer(statePtr, statePtr->inQueueHead, 1); - statePtr->inQueueHead = NULL; - statePtr->inQueueTail = NULL; + if (statePtr->inQueueHead != NULL) { + if ((statePtr->inQueueHead->nextPtr == NULL) + && (statePtr->inQueueHead->nextAdded == + statePtr->inQueueHead->nextRemoved)) { + RecycleBuffer(statePtr, statePtr->inQueueHead, 1); + statePtr->inQueueHead = NULL; + statePtr->inQueueTail = NULL; + } } /* @@ -8116,11 +6829,12 @@ Tcl_SetChannelOption( */ if (statePtr->outputStage != NULL) { - ckfree(statePtr->outputStage); + ckfree((char *) statePtr->outputStage); statePtr->outputStage = NULL; } - if ((statePtr->encoding != NULL) && GotFlag(statePtr, TCL_WRITABLE)) { - statePtr->outputStage = ckalloc(statePtr->bufSize + 2); + if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { + statePtr->outputStage = (char *) + ckalloc((unsigned) (statePtr->bufSize + 2)); } return TCL_OK; } @@ -8130,10 +6844,11 @@ Tcl_SetChannelOption( * * CleanupChannelHandlers -- * - * Removes channel handlers that refer to the supplied interpreter, so - * that if the actual channel is not closed now, these handlers will not - * run on subsequent events on the channel. This would be erroneous, - * because the interpreter no longer has a reference to this channel. + * Removes channel handlers that refer to the supplied interpreter, + * so that if the actual channel is not closed now, these handlers + * will not run on subsequent events on the channel. This would be + * erroneous, because the interpreter no longer has a reference to + * this channel. * * Results: * None. @@ -8145,37 +6860,38 @@ Tcl_SetChannelOption( */ static void -CleanupChannelHandlers( - Tcl_Interp *interp, - Channel *chanPtr) +CleanupChannelHandlers(interp, chanPtr) + Tcl_Interp *interp; + Channel *chanPtr; { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ EventScriptRecord *sPtr, *prevPtr, *nextPtr; /* - * Remove fileevent records on this channel that refer to the given - * interpreter. - */ - - for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL; - sPtr != NULL; sPtr = nextPtr) { - nextPtr = sPtr->nextPtr; - if (sPtr->interp == interp) { - if (prevPtr == NULL) { - statePtr->scriptRecordPtr = nextPtr; - } else { - prevPtr->nextPtr = nextPtr; - } + * 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, sPtr); + Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, + TclChannelEventScriptInvoker, (ClientData) sPtr); - TclDecrRefCount(sPtr->scriptPtr); - ckfree(sPtr); - } else { - prevPtr = sPtr; - } + Tcl_DecrRefCount(sPtr->scriptPtr); + ckfree((char *) sPtr); + } else { + prevPtr = sPtr; + } } } @@ -8184,9 +6900,10 @@ CleanupChannelHandlers( * * Tcl_NotifyChannel -- * - * This procedure is called by a channel driver when a driver detects an - * event on a channel. This procedure is responsible for actually - * handling the event by invoking any channel handler callbacks. + * This procedure is called by a channel driver when a driver + * detects an event on a channel. This procedure is responsible + * for actually handling the event by invoking any channel + * handler callbacks. * * Results: * None. @@ -8198,62 +6915,62 @@ CleanupChannelHandlers( */ void -Tcl_NotifyChannel( - Tcl_Channel channel, /* Channel that detected an event. */ - int mask) /* OR'ed combination of TCL_READABLE, +Tcl_NotifyChannel(channel, mask) + Tcl_Channel channel; /* Channel that detected an event. */ + int mask; /* OR'ed combination of TCL_READABLE, * TCL_WRITABLE, or TCL_EXCEPTION: indicates * which events were detected. */ { Channel *chanPtr = (Channel *) channel; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ ChannelHandler *chPtr; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); NextChannelHandler nh; - Channel *upChanPtr; - const Tcl_ChannelType *upTypePtr; + Channel* upChanPtr; + Tcl_ChannelType* upTypePtr; #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* - * [SF Tcl Bug 943274] For a non-blocking channel without blockmodeproc we - * keep track of actual input coming from the OS so that we can do a - * credible imitation of non-blocking behaviour. + /* [SF Tcl Bug 943274] + * For a non-blocking channel without blockmodeproc we keep track + * of actual input coming from the OS so that we can do a credible + * imitation of non-blocking behaviour. */ if ((mask & TCL_READABLE) && - GotFlag(statePtr, CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && - !GotFlag(statePtr, CHANNEL_TIMER_FEV)) { - SetFlag(statePtr, CHANNEL_HAS_MORE_DATA); + (statePtr->flags & CHANNEL_NONBLOCKING) && + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && + !(statePtr->flags & CHANNEL_TIMER_FEV)) { + + statePtr->flags |= CHANNEL_HAS_MORE_DATA; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ /* - * In contrast to the other API functions this procedure walks towards the - * top of a stack and not down from it. + * In contrast to the other API functions this procedure walks towards + * the top of a stack and not down from it. * * The channel calling this procedure is the one who generated the event, - * and thus does not take part in handling it. IOW, its HandlerProc is not - * called, instead we begin with the channel above it. + * and thus does not take part in handling it. IOW, its HandlerProc is + * not called, instead we begin with the channel above it. * - * This behaviour also allows the transformation channels to generate - * their own events and pass them upward. + * This behaviour also allows the transformation channels to + * generate their own events and pass them upward. */ - while (mask && (chanPtr->upChanPtr != 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) { - mask = upHandlerProc(upChanPtr->instanceData, mask); + mask = (*upHandlerProc) (upChanPtr->instanceData, mask); } - /* - * ELSE: Ignore transformations which are unable to handle the event - * coming from below. Assume that they don't change the mask and pass - * it on. + /* ELSE: + * Ignore transformations which are unable to handle the event + * coming from below. Assume that they don't change the mask and + * pass it on. */ chanPtr = upChanPtr; @@ -8262,31 +6979,32 @@ Tcl_NotifyChannel( channel = (Tcl_Channel) chanPtr; /* - * Here we have either reached the top of the stack or the mask is empty. - * We break out of the procedure if it is the latter. + * Here we have either reached the top of the stack or the mask is + * empty. We break out of the procedure if it is the latter. */ if (!mask) { - return; + return; } /* - * We are now above the topmost channel in a stack and have events left. - * Now call the channel handlers as usual. + * We are now above the topmost channel in a stack and have events + * left. Now call the channel handlers as usual. * * Preserve the channel struct in case the script closes it. */ - - Tcl_Preserve(channel); - Tcl_Preserve(statePtr); + + Tcl_Preserve((ClientData) channel); + Tcl_Preserve((ClientData) statePtr); /* - * If we are flushing in the background, be sure to call FlushChannel for - * writable events. Note that we have to discard the writable event so we - * don't call any write handlers before the flush is complete. + * If we are flushing in the background, be sure to call FlushChannel + * for writable events. Note that we have to discard the writable + * event so we don't call any write handlers before the flush is + * complete. */ - if (GotFlag(statePtr, BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) { + if ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) { FlushChannel(NULL, chanPtr, 1); mask &= ~TCL_WRITABLE; } @@ -8295,12 +7013,12 @@ Tcl_NotifyChannel( * Add this invocation to the list of recursive invocations of * ChannelHandlerEventProc. */ - - nh.nextHandlerPtr = NULL; + + nh.nextHandlerPtr = (ChannelHandler *) NULL; nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr; tsdPtr->nestedHandlerPtr = &nh; - for (chPtr = statePtr->chPtr; chPtr != NULL; ) { + for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) { /* * If this channel handler is interested in any of the events that * have occurred on the channel, invoke its procedure. @@ -8308,7 +7026,7 @@ Tcl_NotifyChannel( if ((chPtr->mask & mask) != 0) { nh.nextHandlerPtr = chPtr->nextPtr; - chPtr->proc(chPtr->clientData, mask); + (*(chPtr->proc))(chPtr->clientData, mask); chPtr = nh.nextHandlerPtr; } else { chPtr = chPtr->nextPtr; @@ -8316,17 +7034,17 @@ Tcl_NotifyChannel( } /* - * Update the notifier interest, since it may have changed after invoking - * event handlers. Skip that if the channel was deleted in the call to the - * channel handler. + * Update the notifier interest, since it may have changed after + * invoking event handlers. Skip that if the channel was deleted + * in the call to the channel handler. */ if (chanPtr->typePtr != NULL) { - UpdateInterest(chanPtr); + UpdateInterest(chanPtr); } - Tcl_Release(statePtr); - Tcl_Release(channel); + Tcl_Release((ClientData) statePtr); + Tcl_Release((ClientData) channel); tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr; } @@ -8336,8 +7054,8 @@ Tcl_NotifyChannel( * * UpdateInterest -- * - * Arrange for the notifier to call us back at appropriate times based on - * the current state of the channel. + * Arrange for the notifier to call us back at appropriate times + * based on the current state of the channel. * * Results: * None. @@ -8349,82 +7067,84 @@ Tcl_NotifyChannel( */ static void -UpdateInterest( - Channel *chanPtr) /* Channel to update. */ +UpdateInterest(chanPtr) + Channel *chanPtr; /* Channel to update. */ { - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ int mask = statePtr->interestMask; /* - * If there are flushed buffers waiting to be written, then we need to - * watch for the channel to become writable. + * If there are flushed buffers waiting to be written, then + * we need to watch for the channel to become writable. */ - if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + if (statePtr->flags & BG_FLUSH_SCHEDULED) { mask |= TCL_WRITABLE; } /* * If there is data in the input queue, and we aren't waiting for more * data, then we need to schedule a timer so we don't block in the - * notifier. Also, cancel the read interest so we don't get duplicate + * notifier. Also, cancel the read interest so we don't get duplicate * events. */ if (mask & TCL_READABLE) { - if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA) - && (statePtr->inQueueHead != NULL) - && IsBufferReady(statePtr->inQueueHead)) { + if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA) + && (statePtr->inQueueHead != (ChannelBuffer *) NULL) + && (statePtr->inQueueHead->nextRemoved < + statePtr->inQueueHead->nextAdded)) { mask &= ~TCL_READABLE; /* * Andreas Kupries, April 11, 2003 * - * Some operating systems (Solaris 2.6 and higher (but not Solaris - * 2.5, go figure)) generate READABLE and EXCEPTION events when - * select()'ing [*] on a plain file, even if EOF was not yet - * reached. This is a problem in the following situation: + * Some operating systems (Solaris 2.6 and higher (but not + * Solaris 2.5, go figure)) generate READABLE and + * EXCEPTION events when select()'ing [*] on a plain file, + * even if EOF was not yet reached. This is a problem in + * the following situation: * - * - An extension asks to get both READABLE and EXCEPTION events. - * - It reads data into a buffer smaller than the buffer used by - * Tcl itself. - * - It does not process all events in the event queue, but only - * one, at least in some situations. + * - An extension asks to get both READABLE and EXCEPTION + * events. + * - It reads data into a buffer smaller than the buffer + * used by Tcl itself. + * - It does not process all events in the event queue, but + * only only one, at least in some situations. * * In that case we can get into a situation where * * - Tcl drops READABLE here, because it has data in its own - * buffers waiting to be read by the extension. + * buffers waiting to be read by the extension. * - A READABLE event is syntesized via timer. * - The OS still reports the EXCEPTION condition on the file. - * - And the extension gets the EXCPTION event first, and handles - * this as EOF. + * - And the extension gets the EXCPTION event first, and + * handles this as EOF. * * End result ==> Premature end of reading from a file. * - * The concrete example is 'Expect', and its [expect] command - * (and at the C-level, deep in the bowels of Expect, - * 'exp_get_next_event'. See marker 'SunOS' for commentary in - * that function too). + * The concrete example is 'Expect', and its [expect] + * command (and at the C-level, deep in the bowels of + * Expect, 'exp_get_next_event'. See marker 'SunOS' for + * commentary in that function too). * - * [*] As the Tcl notifier does. See also for marker 'SunOS' in - * file 'exp_event.c' of Expect. + * [*] As the Tcl notifier does. See also for marker + * 'SunOS' in file 'exp_event.c' of Expect. * - * Our solution here is to drop the interest in the EXCEPTION - * events too. This compiles on all platforms, and also passes the - * testsuite on all of them. + * Our solution here is to drop the interest in the + * EXCEPTION events too. This compiles on all platforms, + * and also passes the testsuite on all of them. */ mask &= ~TCL_EXCEPTION; if (!statePtr->timer) { statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc, - chanPtr); + (ClientData) chanPtr); } } } - ChanWatch(chanPtr, mask); + (chanPtr->typePtr->watchProc)(chanPtr->instanceData, mask); } /* @@ -8432,8 +7152,8 @@ UpdateInterest( * * ChannelTimerProc -- * - * Timer handler scheduled by UpdateInterest to monitor the channel - * buffers until they are empty. + * Timer handler scheduled by UpdateInterest to monitor the + * channel buffers until they are empty. * * Results: * None. @@ -8445,47 +7165,47 @@ UpdateInterest( */ static void -ChannelTimerProc( - ClientData clientData) +ChannelTimerProc(clientData) + ClientData clientData; { - Channel *chanPtr = clientData; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + Channel *chanPtr = (Channel *) clientData; + ChannelState *statePtr = chanPtr->state; /* state info for channel */ - if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA) + if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA) && (statePtr->interestMask & TCL_READABLE) - && (statePtr->inQueueHead != NULL) - && IsBufferReady(statePtr->inQueueHead)) { + && (statePtr->inQueueHead != (ChannelBuffer *) NULL) + && (statePtr->inQueueHead->nextRemoved < + statePtr->inQueueHead->nextAdded)) { /* - * Restart the timer in case a channel handler reenters the event loop - * before UpdateInterest gets called by Tcl_NotifyChannel. + * Restart the timer in case a channel handler reenters the + * event loop before UpdateInterest gets called by Tcl_NotifyChannel. */ - statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,chanPtr); + statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc, + (ClientData) chanPtr); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* - * Set the TIMER flag to notify the higher levels that the driver - * might have no data for us. We do this only if we are in - * non-blocking mode and the driver has no BlockModeProc because only - * then we really don't know if the driver will block or not. A - * similar test is done in "PeekAhead". + /* Set the TIMER flag to notify the higher levels that the + * driver might have no data for us. We do this only if we are + * in non-blocking mode and the driver has no BlockModeProc + * because only then we really don't know if the driver will + * block or not. A similar test is done in "PeekAhead". */ - if (GotFlag(statePtr, CHANNEL_NONBLOCKING) && - (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL)) { - SetFlag(statePtr, CHANNEL_TIMER_FEV); + if ((statePtr->flags & CHANNEL_NONBLOCKING) && + (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL)) { + statePtr->flags |= CHANNEL_TIMER_FEV; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - Tcl_Preserve(statePtr); - Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE); + Tcl_Preserve((ClientData) statePtr); + Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - ResetFlag(statePtr, CHANNEL_TIMER_FEV); + statePtr->flags &= ~CHANNEL_TIMER_FEV; #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - Tcl_Release(statePtr); + Tcl_Release((ClientData) statePtr); } else { statePtr->timer = NULL; UpdateInterest(chanPtr); @@ -8497,75 +7217,80 @@ ChannelTimerProc( * * Tcl_CreateChannelHandler -- * - * Arrange for a given procedure to be invoked whenever the channel - * indicated by the chanPtr arg becomes readable or writable. + * Arrange for a given procedure to be invoked whenever the + * channel indicated by the chanPtr arg becomes readable or + * writable. * * Results: * None. * * Side effects: - * From now on, whenever the I/O channel given by chanPtr becomes ready - * in the way indicated by mask, proc will be invoked. See the manual - * entry for details on the calling sequence to proc. If there is already - * an event handler for chan, proc and clientData, then the mask will be - * updated. + * From now on, whenever the I/O channel given by chanPtr becomes + * ready in the way indicated by mask, proc will be invoked. + * See the manual entry for details on the calling sequence + * to proc. If there is already an event handler for chan, proc + * and clientData, then the mask will be updated. * *---------------------------------------------------------------------- */ void -Tcl_CreateChannelHandler( - Tcl_Channel chan, /* The channel to create the handler for. */ - int mask, /* OR'ed combination of TCL_READABLE, - * TCL_WRITABLE, and TCL_EXCEPTION: indicates - * conditions under which proc should be - * called. Use 0 to disable a registered - * handler. */ - Tcl_ChannelProc *proc, /* Procedure to call for each selected - * event. */ - ClientData clientData) /* Arbitrary data to pass to proc. */ +Tcl_CreateChannelHandler(chan, mask, proc, clientData) + Tcl_Channel chan; /* The channel to create the handler for. */ + int mask; /* OR'ed combination of TCL_READABLE, + * TCL_WRITABLE, and TCL_EXCEPTION: + * indicates conditions under which + * proc should be called. Use 0 to + * disable a registered handler. */ + Tcl_ChannelProc *proc; /* Procedure to call for each + * selected event. */ + ClientData clientData; /* Arbitrary data to pass to proc. */ { ChannelHandler *chPtr; Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* - * Check whether this channel handler is not already registered. If it is - * not, create a new record, else reuse existing record (smash current - * values). + * Check whether this channel handler is not already registered. If + * it is not, create a new record, else reuse existing record (smash + * current values). */ - for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { - if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) && - (chPtr->clientData == clientData)) { - break; - } + for (chPtr = statePtr->chPtr; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { + if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) && + (chPtr->clientData == clientData)) { + break; + } } - if (chPtr == NULL) { - chPtr = ckalloc(sizeof(ChannelHandler)); - chPtr->mask = 0; - chPtr->proc = proc; - chPtr->clientData = clientData; - chPtr->chanPtr = chanPtr; - chPtr->nextPtr = statePtr->chPtr; - statePtr->chPtr = chPtr; + 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; } /* - * The remainder of the initialization below is done regardless of whether - * or not this is a new record or a modification of an old one. + * The remainder of the initialization below is done regardless of + * whether or not this is a new record or a modification of an old + * one. */ chPtr->mask = mask; /* - * Recompute the interest mask for the channel - this call may actually be - * disabling an existing handler. + * Recompute the interest mask for the channel - this call may actually + * be disabling an existing handler. */ - + statePtr->interestMask = 0; - for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { + for (chPtr = statePtr->chPtr; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { statePtr->interestMask |= chPtr->mask; } @@ -8577,53 +7302,55 @@ Tcl_CreateChannelHandler( * * Tcl_DeleteChannelHandler -- * - * Cancel a previously arranged callback arrangement for an IO channel. + * Cancel a previously arranged callback arrangement for an IO + * channel. * * Results: * None. * * Side effects: * If a callback was previously registered for this chan, proc and - * clientData, it is removed and the callback will no longer be called + * clientData , it is removed and the callback will no longer be called * when the channel becomes ready for IO. * *---------------------------------------------------------------------- */ void -Tcl_DeleteChannelHandler( - Tcl_Channel chan, /* The channel for which to remove the - * callback. */ - Tcl_ChannelProc *proc, /* The procedure in the callback to delete. */ - ClientData clientData) /* The client data in the callback to - * delete. */ +Tcl_DeleteChannelHandler(chan, proc, clientData) + Tcl_Channel chan; /* The channel for which to remove the + * callback. */ + Tcl_ChannelProc *proc; /* The procedure in the callback to delete. */ + ClientData clientData; /* The client data in the callback + * to delete. */ + { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ChannelHandler *chPtr, *prevChPtr; Channel *chanPtr = (Channel *) chan; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ NextChannelHandler *nhPtr; /* * Find the entry and the previous one in the list. */ - for (prevChPtr = NULL, chPtr = statePtr->chPtr; chPtr != NULL; - chPtr = chPtr->nextPtr) { - if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData) - && (chPtr->proc == proc)) { - break; - } - prevChPtr = chPtr; + for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { + if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData) + && (chPtr->proc == proc)) { + break; + } + prevChPtr = chPtr; } /* * If not found, return without doing anything. */ - if (chPtr == NULL) { - return; + if (chPtr == (ChannelHandler *) NULL) { + return; } /* @@ -8631,32 +7358,36 @@ Tcl_DeleteChannelHandler( * process the next one instead - we are going to delete *this* one. */ - for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL; - nhPtr = nhPtr->nestedHandlerPtr) { - if (nhPtr->nextHandlerPtr == chPtr) { - nhPtr->nextHandlerPtr = chPtr->nextPtr; - } + for (nhPtr = tsdPtr->nestedHandlerPtr; + 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 == NULL) { - statePtr->chPtr = chPtr->nextPtr; + + if (prevChPtr == (ChannelHandler *) NULL) { + statePtr->chPtr = chPtr->nextPtr; } else { - prevChPtr->nextPtr = chPtr->nextPtr; + prevChPtr->nextPtr = chPtr->nextPtr; } - ckfree(chPtr); + ckfree((char *) chPtr); /* * Recompute the interest list for the channel, so that infinite loops - * will not result if Tcl_DeleteChannelHandler is called inside an event. + * will not result if Tcl_DeleteChannelHandler is called inside an + * event. */ statePtr->interestMask = 0; - for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { - statePtr->interestMask |= chPtr->mask; + for (chPtr = statePtr->chPtr; + chPtr != (ChannelHandler *) NULL; + chPtr = chPtr->nextPtr) { + statePtr->interestMask |= chPtr->mask; } UpdateInterest(statePtr->topChanPtr); @@ -8667,8 +7398,8 @@ Tcl_DeleteChannelHandler( * * DeleteScriptRecord -- * - * Delete a script record for this combination of channel, interp and - * mask. + * Delete a script record for this combination of channel, interp + * and mask. * * Results: * None. @@ -8680,36 +7411,36 @@ Tcl_DeleteChannelHandler( */ static void -DeleteScriptRecord( - Tcl_Interp *interp, /* Interpreter in which script was to be - * executed. */ - Channel *chanPtr, /* The channel for which to delete the script - * record (if any). */ - int mask) /* Events in mask must exactly match mask of - * script to delete. */ -{ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ +DeleteScriptRecord(interp, chanPtr, mask) + Tcl_Interp *interp; /* Interpreter in which script was to be + * executed. */ + Channel *chanPtr; /* The channel for which to delete the + * script record (if any). */ + int mask; /* Events in mask must exactly match mask + * of script to delete. */ +{ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ EventScriptRecord *esPtr, *prevEsPtr; - for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL; - prevEsPtr = esPtr, esPtr = esPtr->nextPtr) { - if ((esPtr->interp == interp) && (esPtr->mask == mask)) { - if (esPtr == statePtr->scriptRecordPtr) { - statePtr->scriptRecordPtr = esPtr->nextPtr; - } else { - CLANG_ASSERT(prevEsPtr); - prevEsPtr->nextPtr = esPtr->nextPtr; - } - - Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, - TclChannelEventScriptInvoker, esPtr); + 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; + } - TclDecrRefCount(esPtr->scriptPtr); - ckfree(esPtr); + Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, + TclChannelEventScriptInvoker, (ClientData) esPtr); + + Tcl_DecrRefCount(esPtr->scriptPtr); + ckfree((char *) esPtr); - break; - } + break; + } } } @@ -8731,54 +7462,40 @@ DeleteScriptRecord( */ static void -CreateScriptRecord( - Tcl_Interp *interp, /* Interpreter in which to execute the stored - * script. */ - Channel *chanPtr, /* Channel for which script is to be stored */ - int mask, /* Set of events for which script will be - * invoked. */ - Tcl_Obj *scriptPtr) /* Pointer to script object. */ -{ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ +CreateScriptRecord(interp, chanPtr, mask, scriptPtr) + Tcl_Interp *interp; /* Interpreter in which to execute + * the stored script. */ + Channel *chanPtr; /* Channel for which script is to + * be stored. */ + int mask; /* Set of events for which script + * will be invoked. */ + Tcl_Obj *scriptPtr; /* Pointer to script object. */ +{ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ EventScriptRecord *esPtr; - int makeCH; - for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) { - if ((esPtr->interp == interp) && (esPtr->mask == mask)) { - TclDecrRefCount(esPtr->scriptPtr); - esPtr->scriptPtr = NULL; - break; - } + for (esPtr = statePtr->scriptRecordPtr; + esPtr != (EventScriptRecord *) NULL; + esPtr = esPtr->nextPtr) { + if ((esPtr->interp == interp) && (esPtr->mask == mask)) { + Tcl_DecrRefCount(esPtr->scriptPtr); + esPtr->scriptPtr = (Tcl_Obj *) NULL; + break; + } } - - makeCH = (esPtr == NULL); - - if (makeCH) { - esPtr = ckalloc(sizeof(EventScriptRecord)); + 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; } - - /* - * Initialize the structure before calling Tcl_CreateChannelHandler, - * because a reflected channel caling 'chan postevent' aka - * 'Tcl_NotifyChannel' in its 'watch'Proc will invoke - * 'TclChannelEventScriptInvoker' immediately, and we do not wish it to - * see uninitialized memory and crash. See [Bug 2918110]. - */ - esPtr->chanPtr = chanPtr; esPtr->interp = interp; esPtr->mask = mask; Tcl_IncrRefCount(scriptPtr); esPtr->scriptPtr = scriptPtr; - - if (makeCH) { - esPtr->nextPtr = statePtr->scriptRecordPtr; - statePtr->scriptRecordPtr = esPtr; - - Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask, - TclChannelEventScriptInvoker, esPtr); - } } /* @@ -8786,9 +7503,9 @@ CreateScriptRecord( * * TclChannelEventScriptInvoker -- * - * Invokes a script scheduled by "fileevent" for when the channel becomes - * ready for IO. This function is invoked by the channel handler which - * was created by the Tcl "fileevent" command. + * Invokes a script scheduled by "fileevent" for when the channel + * becomes ready for IO. This function is invoked by the channel + * handler which was created by the Tcl "fileevent" command. * * Results: * None. @@ -8800,46 +7517,46 @@ CreateScriptRecord( */ void -TclChannelEventScriptInvoker( - ClientData clientData, /* The script+interp record. */ - int mask) /* Not used. */ +TclChannelEventScriptInvoker(clientData, mask) + ClientData clientData; /* The script+interp record. */ + int mask; /* Not used. */ { Tcl_Interp *interp; /* Interpreter in which to eval the script. */ Channel *chanPtr; /* The channel for which this handler is - * registered. */ + * registered. */ EventScriptRecord *esPtr; /* The event script + interpreter to eval it - * in. */ + * in. */ int result; /* Result of call to eval script. */ - esPtr = clientData; - chanPtr = esPtr->chanPtr; - mask = esPtr->mask; - interp = esPtr->interp; + esPtr = (EventScriptRecord *) clientData; + chanPtr = esPtr->chanPtr; + mask = esPtr->mask; + interp = esPtr->interp; /* - * We must preserve the interpreter so we can report errors on it later. - * Note that we do not need to preserve the channel because that is done - * by Tcl_NotifyChannel before calling channel handlers. + * We must preserve the interpreter so we can report errors on it + * later. Note that we do not need to preserve the channel because + * that is done by Tcl_NotifyChannel before calling channel handlers. */ - - Tcl_Preserve(interp); + + Tcl_Preserve((ClientData) interp); result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL); /* - * On error, cause a background error and remove the channel handler and - * the script record. + * On error, cause a background error and remove the channel handler + * and the script record. * * NOTE: Must delete channel handler before causing the background error * because the background error may want to reinstall the handler. */ - + if (result != TCL_OK) { if (chanPtr->typePtr != NULL) { DeleteScriptRecord(interp, chanPtr, mask); } - Tcl_BackgroundException(interp, result); + Tcl_BackgroundError(interp); } - Tcl_Release(interp); + Tcl_Release((ClientData) interp); } /* @@ -8847,10 +7564,10 @@ TclChannelEventScriptInvoker( * * Tcl_FileEventObjCmd -- * - * This procedure implements the "fileevent" Tcl command. See the user - * documentation for details on what it does. This command is based on - * the Tk command "fileevent" which in turn is based on work contributed - * by Mark Diekhans. + * This procedure implements the "fileevent" Tcl command. See the + * user documentation for details on what it does. This command is + * based on the Tk command "fileevent" which in turn is based on work + * contributed by Mark Diekhans. * * Results: * A standard Tcl result. @@ -8863,21 +7580,23 @@ TclChannelEventScriptInvoker( /* ARGSUSED */ int -Tcl_FileEventObjCmd( - ClientData clientData, /* Not used. */ - Tcl_Interp *interp, /* Interpreter in which the channel for which - * to create the handler is found. */ - int objc, /* Number of arguments. */ - Tcl_Obj *const objv[]) /* Argument objects. */ -{ - Channel *chanPtr; /* The channel to create the handler for. */ - ChannelState *statePtr; /* State info for channel */ - Tcl_Channel chan; /* The opaque type for the channel. */ - const char *chanName; - int modeIndex; /* Index of mode argument. */ +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. */ + int objc; /* Number of arguments. */ + Tcl_Obj *CONST objv[]; /* Argument objects. */ +{ + Channel *chanPtr; /* The channel to create + * the handler for. */ + ChannelState *statePtr; /* state info for channel */ + Tcl_Channel chan; /* The opaque type for the channel. */ + char *chanName; + int modeIndex; /* Index of mode argument. */ int mask; - static const char *const modeOptions[] = {"readable", "writable", NULL}; - static const int maskArray[] = {TCL_READABLE, TCL_WRITABLE}; + static CONST char *modeOptions[] = {"readable", "writable", NULL}; + static CONST int maskArray[] = {TCL_READABLE, TCL_WRITABLE}; if ((objc != 3) && (objc != 4)) { Tcl_WrongNumArgs(interp, 1, objv, "channelId event ?script?"); @@ -8889,123 +7608,85 @@ Tcl_FileEventObjCmd( } mask = maskArray[modeIndex]; - chanName = TclGetString(objv[1]); + chanName = Tcl_GetString(objv[1]); chan = Tcl_GetChannel(interp, chanName, NULL); - if (chan == NULL) { + 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", 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. */ if (objc == 3) { EventScriptRecord *esPtr; - - for (esPtr = statePtr->scriptRecordPtr; esPtr != NULL; - esPtr = esPtr->nextPtr) { + for (esPtr = statePtr->scriptRecordPtr; + esPtr != (EventScriptRecord *) NULL; + esPtr = esPtr->nextPtr) { if ((esPtr->interp == interp) && (esPtr->mask == mask)) { Tcl_SetObjResult(interp, esPtr->scriptPtr); break; } } - return TCL_OK; + return TCL_OK; } /* * If we are supposed to delete a stored script, do so. */ - if (*(TclGetString(objv[3])) == '\0') { - DeleteScriptRecord(interp, chanPtr, mask); - return TCL_OK; + if (*(Tcl_GetString(objv[3])) == '\0') { + DeleteScriptRecord(interp, chanPtr, mask); + return TCL_OK; } /* - * Make the script record that will link between the event and the script - * to invoke. This also creates a channel event handler which will - * evaluate the script in the supplied interpreter. + * Make the script record that will link between the event and the + * script to invoke. This also creates a channel event handler which + * will evaluate the script in the supplied interpreter. */ CreateScriptRecord(interp, chanPtr, mask, objv[3]); - + return TCL_OK; } /* *---------------------------------------------------------------------- * - * ZeroTransferTimerProc -- - * - * Timer handler scheduled by TclCopyChannel so that -command is - * called asynchronously even when -size is 0. - * - * Results: - * None. - * - * Side effects: - * Calls CopyData for -command invocation. - * - *---------------------------------------------------------------------- - */ - -static void -ZeroTransferTimerProc( - ClientData clientData) -{ - /* calling CopyData with mask==0 still implies immediate invocation of the - * -command callback, and completion of the fcopy. - */ - CopyData(clientData, 0); -} - -/* - *---------------------------------------------------------------------- - * * TclCopyChannel -- * * This routine copies data from one channel to another, either - * synchronously or asynchronously. If a command script is supplied, the - * operation runs in the background. The script is invoked when the copy - * completes. Otherwise the function waits until the copy is completed - * before returning. + * synchronously or asynchronously. If a command script is + * supplied, the operation runs in the background. The script + * is invoked when the copy completes. Otherwise the function + * waits until the copy is completed before returning. * * Results: * A standard Tcl result. * * Side effects: - * May schedule a background copy operation that causes both channels to - * be marked busy. + * May schedule a background copy operation that causes both + * channels to be marked busy. * *---------------------------------------------------------------------- */ int -TclCopyChannelOld( - Tcl_Interp *interp, /* Current interpreter. */ - Tcl_Channel inChan, /* Channel to read from. */ - Tcl_Channel outChan, /* Channel to write to. */ - int toRead, /* Amount of data to copy, or -1 for all. */ - Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */ -{ - return TclCopyChannel(interp, inChan, outChan, (Tcl_WideInt) toRead, - cmdPtr); -} - -int -TclCopyChannel( - Tcl_Interp *interp, /* Current interpreter. */ - Tcl_Channel inChan, /* Channel to read from. */ - Tcl_Channel outChan, /* Channel to write to. */ - Tcl_WideInt toRead, /* Amount of data to copy, or -1 for all. */ - Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */ +TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) + Tcl_Interp *interp; /* Current interpreter. */ + Tcl_Channel inChan; /* Channel to read from. */ + Tcl_Channel outChan; /* Channel to write to. */ + int toRead; /* Amount of data to copy, or -1 for all. */ + Tcl_Obj *cmdPtr; /* Pointer to script to execute or NULL. */ { Channel *inPtr = (Channel *) inChan; Channel *outPtr = (Channel *) outChan; @@ -9014,70 +7695,77 @@ TclCopyChannel( CopyState *csPtr; int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0; - inStatePtr = inPtr->state; - outStatePtr = outPtr->state; + inStatePtr = inPtr->state; + outStatePtr = outPtr->state; - if (BUSY_STATE(inStatePtr, TCL_READABLE)) { + if (BUSY_STATE(inStatePtr,TCL_READABLE)) { if (interp) { - Tcl_AppendResult(interp, "channel \"", + Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"", Tcl_GetChannelName(inChan), "\" is busy", NULL); } return TCL_ERROR; } - if (BUSY_STATE(outStatePtr, TCL_WRITABLE)) { + if (BUSY_STATE(outStatePtr,TCL_WRITABLE)) { if (interp) { - Tcl_AppendResult(interp, "channel \"", + Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"", Tcl_GetChannelName(outChan), "\" is busy", NULL); } return TCL_ERROR; } - readFlags = inStatePtr->flags; - writeFlags = outStatePtr->flags; + readFlags = inStatePtr->flags; + writeFlags = outStatePtr->flags; /* - * Set up the blocking mode appropriately. Background copies need - * non-blocking channels. Foreground copies need blocking channels. If - * there is an error, restore the old blocking mode. + * Set up the blocking mode appropriately. Background copies need + * non-blocking channels. Foreground copies need blocking channels. + * If there is an error, restore the old blocking mode. */ if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) { - if (SetBlockMode(interp, inPtr, nonBlocking ? - TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) { + if (SetBlockMode(interp, inPtr, + nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) + != TCL_OK) { return TCL_ERROR; } - } - if ((inPtr!=outPtr) && (nonBlocking!=(writeFlags&CHANNEL_NONBLOCKING)) && - (SetBlockMode(NULL, outPtr, nonBlocking ? - TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) && - (nonBlocking != (readFlags & CHANNEL_NONBLOCKING))) { - SetBlockMode(NULL, inPtr, (readFlags & CHANNEL_NONBLOCKING) - ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); - return TCL_ERROR; + } + if (inPtr != outPtr) { + if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) { + if (SetBlockMode(NULL, outPtr, + nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) + != TCL_OK) { + if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) { + SetBlockMode(NULL, inPtr, + (readFlags & CHANNEL_NONBLOCKING) + ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); + return TCL_ERROR; + } + } + } } /* * Make sure the output side is unbuffered. */ - outStatePtr->flags = (outStatePtr->flags & ~CHANNEL_LINEBUFFERED) - | CHANNEL_UNBUFFERED; + outStatePtr->flags = (outStatePtr->flags & ~(CHANNEL_LINEBUFFERED)) + | CHANNEL_UNBUFFERED; /* * Allocate a new CopyState to maintain info about the current copy in - * progress. This structure will be deallocated when the copy is + * progress. This structure will be deallocated when the copy is * completed. */ - csPtr = 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 = (Tcl_WideInt) 0; - csPtr->interp = interp; + csPtr->toRead = toRead; + csPtr->total = 0; + csPtr->interp = interp; if (cmdPtr) { Tcl_IncrRefCount(cmdPtr); } @@ -9087,16 +7775,6 @@ TclCopyChannel( outStatePtr->csPtrW = csPtr; /* - * Special handling of -size 0 async transfers, so that the -command is - * still called asynchronously. - */ - - if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) { - Tcl_CreateTimerHandler(0, ZeroTransferTimerProc, csPtr); - return 0; - } - - /* * Start copying data between the channels. */ @@ -9108,8 +7786,8 @@ TclCopyChannel( * * CopyData -- * - * This function implements the lowest level of the copying mechanism for - * TclCopyChannel. + * This function implements the lowest level of the copying + * mechanism for TclCopyChannel. * * Results: * Returns TCL_OK on success, else TCL_ERROR. @@ -9121,20 +7799,19 @@ TclCopyChannel( */ static int -CopyData( - CopyState *csPtr, /* State of copy operation. */ - int mask) /* Current channel event flags. */ +CopyData(csPtr, mask) + CopyState *csPtr; /* State of copy operation. */ + int mask; /* Current channel event flags. */ { Tcl_Interp *interp; - Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL; + Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL; Tcl_Channel inChan, outChan; ChannelState *inStatePtr, *outStatePtr; - int result = TCL_OK, size, sizeb; - Tcl_WideInt total; - const char *buffer; - int inBinary, outBinary, sameEncoding; - /* Encoding control */ - int underflow; /* Input underflow */ + int result = TCL_OK, size, total, sizeb; + char* buffer; + + int inBinary, outBinary, sameEncoding; /* Encoding control */ + int underflow; /* input underflow */ inChan = (Tcl_Channel) csPtr->readPtr; outChan = (Tcl_Channel) csPtr->writePtr; @@ -9146,108 +7823,95 @@ CopyData( /* * Copy the data the slow way, using the translation mechanism. * - * Note: We have make sure that we use the topmost channel in a stack for - * the copying. The caller uses Tcl_GetChannel to access it, and thus gets - * the bottom of the stack. + * Note: We have make sure that we use the topmost channel in a stack + * for the copying. The caller uses Tcl_GetChannel to access it, and + * thus gets the bottom of the stack. */ - inBinary = (inStatePtr->encoding == NULL); - outBinary = (outStatePtr->encoding == NULL); - sameEncoding = (inStatePtr->encoding == outStatePtr->encoding); + inBinary = (inStatePtr->encoding == NULL); + outBinary = (outStatePtr->encoding == NULL); + sameEncoding = (inStatePtr->encoding == outStatePtr->encoding); if (!(inBinary || sameEncoding)) { - TclNewObj(bufObj); - Tcl_IncrRefCount(bufObj); + bufObj = Tcl_NewObj (); + Tcl_IncrRefCount (bufObj); } - while (csPtr->toRead != (Tcl_WideInt) 0) { + while (csPtr->toRead != 0) { /* * Check for unreported background errors. */ - Tcl_GetChannelError(inChan, &msg); - if ((inStatePtr->unreportedError != 0) || (msg != NULL)) { + if (inStatePtr->unreportedError != 0) { Tcl_SetErrno(inStatePtr->unreportedError); inStatePtr->unreportedError = 0; goto readError; } - Tcl_GetChannelError(outChan, &msg); - if ((outStatePtr->unreportedError != 0) || (msg != NULL)) { + if (outStatePtr->unreportedError != 0) { Tcl_SetErrno(outStatePtr->unreportedError); outStatePtr->unreportedError = 0; goto writeError; } - + if (cmdPtr && (mask == 0)) { /* * In async mode, we skip reading synchronously and fake an * underflow instead to prime the readable fileevent. */ - size = 0; + size = 0; underflow = 1; } else { /* * Read up to bufSize bytes. */ - if ((csPtr->toRead == (Tcl_WideInt) -1) - || (csPtr->toRead > (Tcl_WideInt) csPtr->bufSize)) { - sizeb = csPtr->bufSize; + if ((csPtr->toRead == -1) || (csPtr->toRead > csPtr->bufSize)) { + sizeb = csPtr->bufSize; } else { - sizeb = (int) csPtr->toRead; + sizeb = csPtr->toRead; } if (inBinary || sameEncoding) { - size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb, - !GotFlag(inStatePtr, CHANNEL_NONBLOCKING)); + size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb); } else { - size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, - 0 /* No append */); + size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, 0 /* No append */); } - underflow = (size >= 0) && (size < sizeb); /* Input underflow */ + underflow = (size >= 0) && (size < sizeb); /* input underflow */ } if (size < 0) { - readError: - if (interp) { - TclNewObj(errObj); - Tcl_AppendStringsToObj(errObj, "error reading \"", - Tcl_GetChannelName(inChan), "\": ", NULL); - if (msg != NULL) { - Tcl_AppendObjToObj(errObj, msg); - } else { - Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), - NULL); - } - } - if (msg != NULL) { - Tcl_DecrRefCount(msg); - } + readError: + errObj = Tcl_NewObj(); + Tcl_AppendStringsToObj(errObj, "error reading \"", + Tcl_GetChannelName(inChan), "\": ", + Tcl_PosixError(interp), (char *) NULL); break; } else if (underflow) { /* - * We had an underflow on the read side. If we are at EOF, and not - * in the synchronous part of an asynchronous fcopy, then the - * copying is done, otherwise set up a channel handler to detect - * when the channel becomes readable again. + * We had an underflow on the read side. If we are at + * EOF, and not in the synchronous part of an asynchronous + * fcopy, then the copying is done, otherwise set up a + * channel handler to detect when the channel becomes + * readable again. */ - + if ((size == 0) && Tcl_Eof(inChan) && !(cmdPtr && (mask == 0))) { break; } - if (cmdPtr && (!Tcl_Eof(inChan) || (mask == 0)) && - !(mask & TCL_READABLE)) { + if (((!Tcl_Eof(inChan)) || (cmdPtr && (mask == 0))) && + !(mask & TCL_READABLE)) { if (mask & TCL_WRITABLE) { - Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr); + Tcl_DeleteChannelHandler(outChan, CopyEventProc, + (ClientData) csPtr); } - Tcl_CreateChannelHandler(inChan, TCL_READABLE, CopyEventProc, - csPtr); + Tcl_CreateChannelHandler(inChan, TCL_READABLE, + CopyEventProc, (ClientData) csPtr); } if (size == 0) { - if (bufObj != NULL) { - TclDecrRefCount(bufObj); - bufObj = NULL; + if (bufObj != (Tcl_Obj*) NULL) { + Tcl_DecrRefCount (bufObj); + bufObj = (Tcl_Obj*) NULL; } return TCL_OK; } @@ -9261,7 +7925,7 @@ CopyData( buffer = csPtr->buffer; sizeb = size; } else { - buffer = TclGetStringFromObj(bufObj, &sizeb); + buffer = Tcl_GetStringFromObj (bufObj, &sizeb); } if (outBinary || sameEncoding) { @@ -9283,29 +7947,19 @@ CopyData( */ if (sizeb < 0) { - writeError: - if (interp) { - TclNewObj(errObj); - Tcl_AppendStringsToObj(errObj, "error writing \"", - Tcl_GetChannelName(outChan), "\": ", NULL); - if (msg != NULL) { - Tcl_AppendObjToObj(errObj, msg); - } else { - Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), - NULL); - } - } - if (msg != NULL) { - Tcl_DecrRefCount(msg); - } + writeError: + errObj = Tcl_NewObj(); + Tcl_AppendStringsToObj(errObj, "error writing \"", + Tcl_GetChannelName(outChan), "\": ", + Tcl_PosixError(interp), (char *) NULL); break; } /* - * Update the current byte count. Do it now so the count is valid - * before a return or break takes us out of the loop. The invariant at - * the top of the loop should be that csPtr->toRead holds the number - * of bytes left to copy. + * Update the current byte count. Do it now so the count is + * valid before a return or break takes us out of the loop. + * The invariant at the top of the loop should be that + * csPtr->toRead holds the number of bytes left to copy. */ if (csPtr->toRead != -1) { @@ -9317,91 +7971,89 @@ CopyData( * 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, + * Check to see if the write is happening in the background. If so, * stop copying and wait for the channel to become writable again. * After input underflow we already installed a readable handler * therefore we don't need a writable handler. */ - if (!underflow && GotFlag(outStatePtr, BG_FLUSH_SCHEDULED)) { + if ( ! underflow && (outStatePtr->flags & BG_FLUSH_SCHEDULED) ) { if (!(mask & TCL_WRITABLE)) { if (mask & TCL_READABLE) { - Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr); + Tcl_DeleteChannelHandler(inChan, CopyEventProc, + (ClientData) csPtr); } Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, - CopyEventProc, csPtr); + CopyEventProc, (ClientData) csPtr); } - if (bufObj != NULL) { - TclDecrRefCount(bufObj); - bufObj = NULL; + if (bufObj != (Tcl_Obj*) NULL) { + Tcl_DecrRefCount (bufObj); + bufObj = (Tcl_Obj*) NULL; } return TCL_OK; } /* - * For background copies, we only do one buffer per invocation so we - * don't starve the rest of the system. + * For background copies, we only do one buffer per invocation so + * we don't starve the rest of the system. */ if (cmdPtr && (csPtr->toRead != 0)) { /* - * The first time we enter this code, there won't be a channel - * handler established yet, so do it here. + * The first time we enter this code, there won't be a + * channel handler established yet, so do it here. */ if (mask == 0) { - Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc, - csPtr); + Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, + CopyEventProc, (ClientData) csPtr); } - if (bufObj != NULL) { - TclDecrRefCount(bufObj); - bufObj = NULL; + if (bufObj != (Tcl_Obj*) NULL) { + Tcl_DecrRefCount (bufObj); + bufObj = (Tcl_Obj*) NULL; } return TCL_OK; } } /* while */ - if (bufObj != NULL) { - TclDecrRefCount(bufObj); - bufObj = NULL; + if (bufObj != (Tcl_Obj*) NULL) { + Tcl_DecrRefCount (bufObj); + bufObj = (Tcl_Obj*) NULL; } /* - * Make the callback or return the number of bytes transferred. The local - * total is used because StopCopy frees csPtr. + * Make the callback or return the number of bytes transferred. + * The local total is used because StopCopy frees csPtr. */ total = csPtr->total; if (cmdPtr && interp) { - int code; - /* - * Get a private copy of the command so we can mutate it by adding - * arguments. Note that StopCopy frees our saved reference to the - * original command obj. + * Get a private copy of the command so we can mutate it + * by adding arguments. Note that StopCopy frees our saved + * reference to the original command obj. */ cmdPtr = Tcl_DuplicateObj(cmdPtr); Tcl_IncrRefCount(cmdPtr); StopCopy(csPtr); - Tcl_Preserve(interp); + Tcl_Preserve((ClientData) interp); - Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewWideIntObj(total)); + Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewIntObj(total)); if (errObj) { Tcl_ListObjAppendElement(interp, cmdPtr, errObj); } - code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL); - if (code != TCL_OK) { - Tcl_BackgroundException(interp, code); + if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) { + Tcl_BackgroundError(interp); result = TCL_ERROR; } - TclDecrRefCount(cmdPtr); - Tcl_Release(interp); + Tcl_DecrRefCount(cmdPtr); + Tcl_Release((ClientData) interp); } else { StopCopy(csPtr); if (interp) { @@ -9410,7 +8062,7 @@ CopyData( result = TCL_ERROR; } else { Tcl_ResetResult(interp); - Tcl_SetObjResult(interp, Tcl_NewWideIntObj(total)); + Tcl_SetIntObj(Tcl_GetObjResult(interp), total); } } } @@ -9422,12 +8074,13 @@ CopyData( * * DoRead -- * - * Reads a given number of bytes from a channel. No encoding conversions - * are applied to the bytes being read. + * Reads a given number of bytes from a channel. + * + * No encoding conversions are applied to the bytes being read. * * Results: - * The number of characters read, or -1 on error. Use Tcl_GetErrno() to - * retrieve the error code for the error that occurred. + * The number of characters read, or -1 on error. Use Tcl_GetErrno() + * to retrieve the error code for the error that occurred. * * Side effects: * May cause input to be buffered. @@ -9436,65 +8089,60 @@ CopyData( */ static int -DoRead( - Channel *chanPtr, /* The channel from which to read. */ - char *bufPtr, /* Where to store input read. */ - int toRead, /* Maximum number of bytes to read. */ - int allowShortReads) /* Allow half-blocking (pipes,sockets) */ -{ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - int copied; /* How many characters were copied into the - * result string? */ - int copiedNow; /* How many characters were copied from the - * current input buffer? */ +DoRead(chanPtr, bufPtr, toRead) + Channel *chanPtr; /* The channel from which to read. */ + char *bufPtr; /* Where to store input read. */ + int toRead; /* Maximum number of bytes to read. */ +{ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ + int copied; /* How many characters were copied into + * the result string? */ + int copiedNow; /* How many characters were copied from + * the current input buffer? */ int result; /* Of calling GetInput. */ /* - * If we have not encountered a sticky EOF, clear the EOF bit. Either way - * clear the BLOCKED bit. We want to discover these anew during each - * operation. + * If we have not encountered a sticky EOF, clear the EOF bit. Either + * way clear the BLOCKED bit. We want to discover these anew during + * each operation. */ - if (!GotFlag(statePtr, CHANNEL_STICKY_EOF)) { - ResetFlag(statePtr, CHANNEL_EOF); + if (!(statePtr->flags & CHANNEL_STICKY_EOF)) { + statePtr->flags &= ~CHANNEL_EOF; } - ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA); - + 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 (GotFlag(statePtr, CHANNEL_EOF)) { + copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied, + toRead - copied); + if (copiedNow == 0) { + if (statePtr->flags & CHANNEL_EOF) { goto done; - } - if (GotFlag(statePtr, CHANNEL_BLOCKED)) { - if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + } + if (statePtr->flags & CHANNEL_BLOCKED) { + if (statePtr->flags & CHANNEL_NONBLOCKING) { goto done; - } - ResetFlag(statePtr, 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; - } - } else if (allowShortReads) { - copied += copiedNow; - break; + } } } - ResetFlag(statePtr, CHANNEL_BLOCKED); + statePtr->flags &= (~(CHANNEL_BLOCKED)); + done: /* - * Update the notifier state so we don't block while there is still data - * in the buffers. + * Update the notifier state so we don't block while there is still + * data in the buffers. */ - done: UpdateInterest(chanPtr); return copied; } @@ -9504,13 +8152,13 @@ DoRead( * * CopyAndTranslateBuffer -- * - * Copy at most one buffer of input to the result space, doing eol - * translations according to mode in effect currently. + * Copy at most one buffer of input to the result space, doing + * eol translations according to mode in effect currently. * * Results: - * Number of bytes stored in the result buffer (as opposed to the number - * of bytes read from the channel). May return zero if no input is - * available to be translated. + * Number of bytes stored in the result buffer (as opposed to the + * number of bytes read from the channel). May return + * zero if no input is available to be translated. * * Side effects: * Consumes buffered input. May deallocate one buffer. @@ -9519,208 +8167,220 @@ DoRead( */ static int -CopyAndTranslateBuffer( - 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? */ +CopyAndTranslateBuffer(statePtr, result, space) + ChannelState *statePtr; /* Channel state from which to read input. */ + char *result; /* Where to store the copied input. */ + int space; /* How many bytes are available in result + * to store the copied input? */ { ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */ - int bytesInBuffer; /* How many bytes are available to be copied - * in the current input buffer? */ + int bytesInBuffer; /* How many bytes are available to be + * copied in the current input buffer? */ int copied; /* How many characters were already copied - * into the destination space? */ - int i; /* Iterates over the copied input looking for - * the input eofChar. */ - + * into the destination space? */ + int i; /* Iterates over the copied input looking + * 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. + * 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 == NULL) { - return 0; + + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { + return 0; } bufPtr = statePtr->inQueueHead; - bytesInBuffer = BytesLeft(bufPtr); + bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved; copied = 0; switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: - if (bytesInBuffer == 0) { - return 0; - } - - /* - * Copy the current chunk into the result buffer. - */ - - if (bytesInBuffer < space) { - space = bytesInBuffer; - } - memcpy(result, RemovePoint(bufPtr), (size_t) space); - bufPtr->nextRemoved += space; - copied = space; - break; - case TCL_TRANSLATE_CR: { - char *end; - - if (bytesInBuffer == 0) { - return 0; - } - - /* - * Copy the current chunk into the result buffer, then replace all \r - * with \n. - */ + case TCL_TRANSLATE_LF: { + if (bytesInBuffer == 0) { + return 0; + } - if (bytesInBuffer < space) { - space = bytesInBuffer; - } - memcpy(result, RemovePoint(bufPtr), (size_t) space); - bufPtr->nextRemoved += space; - copied = space; + /* + * Copy the current chunk into the result buffer. + */ - for (end = result + copied; result < end; result++) { - if (*result == '\r') { - *result = '\n'; + if (bytesInBuffer < space) { + space = bytesInBuffer; } + memcpy((VOID *) result, + (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); + bufPtr->nextRemoved += space; + copied = space; + break; } - break; - } - case TCL_TRANSLATE_CRLF: { - char *src, *end, *dst; - int curByte; - - /* - * If there is a held-back "\r" at EOF, produce it now. - */ + case TCL_TRANSLATE_CR: { + char *end; + + if (bytesInBuffer == 0) { + return 0; + } - if (bytesInBuffer == 0) { - if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) == - (INPUT_SAW_CR | CHANNEL_EOF)) { - result[0] = '\r'; - ResetFlag(statePtr, INPUT_SAW_CR); - return 1; - } - return 0; + /* + * Copy the current chunk into the result buffer, then + * replace all \r with \n. + */ + + if (bytesInBuffer < space) { + space = bytesInBuffer; + } + memcpy((VOID *) result, + (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); + bufPtr->nextRemoved += space; + copied = space; + + for (end = result + copied; result < end; result++) { + if (*result == '\r') { + *result = '\n'; + } + } + break; } + case TCL_TRANSLATE_CRLF: { + char *src, *end, *dst; + int curByte; + + /* + * 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 (bytesInBuffer < space) { - space = bytesInBuffer; - } - memcpy(result, RemovePoint(bufPtr), (size_t) space); - bufPtr->nextRemoved += space; - copied = space; - - end = result + copied; - dst = result; - for (src = result; src < end; src++) { - curByte = *src; - if (curByte == '\n') { - ResetFlag(statePtr, INPUT_SAW_CR); - } else if (GotFlag(statePtr, INPUT_SAW_CR)) { - ResetFlag(statePtr, INPUT_SAW_CR); - *dst = '\r'; - dst++; - } - if (curByte == '\r') { - SetFlag(statePtr, INPUT_SAW_CR); - } else { - *dst = (char) curByte; - dst++; + /* + * Copy the current chunk and replace "\r\n" with "\n" + * (but not standalone "\r"!). + */ + + if (bytesInBuffer < space) { + space = bytesInBuffer; + } + memcpy((VOID *) result, + (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); + bufPtr->nextRemoved += space; + copied = space; + + end = result + copied; + dst = result; + for (src = result; src < end; src++) { + curByte = *src; + if (curByte == '\n') { + statePtr->flags &= ~INPUT_SAW_CR; + } else if (statePtr->flags & INPUT_SAW_CR) { + statePtr->flags &= ~INPUT_SAW_CR; + *dst = '\r'; + dst++; + } + if (curByte == '\r') { + statePtr->flags |= INPUT_SAW_CR; + } else { + *dst = (char) curByte; + dst++; + } } + copied = dst - result; + break; } - copied = dst - result; - break; - } - 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". - */ + case TCL_TRANSLATE_AUTO: { + char *src, *end, *dst; + int curByte; + + if (bytesInBuffer == 0) { + return 0; + } - if (bytesInBuffer < space) { - space = bytesInBuffer; - } - memcpy(result, RemovePoint(bufPtr), (size_t) space); - bufPtr->nextRemoved += space; - copied = space; - - end = result + copied; - dst = result; - for (src = result; src < end; src++) { - curByte = *src; - if (curByte == '\r') { - SetFlag(statePtr, INPUT_SAW_CR); - *dst = '\n'; - dst++; - } else { - if ((curByte != '\n') || !GotFlag(statePtr, INPUT_SAW_CR)) { - *dst = (char) curByte; + /* + * Loop over the current buffer, converting "\r" and "\r\n" + * to "\n". + */ + + if (bytesInBuffer < space) { + space = bytesInBuffer; + } + memcpy((VOID *) result, + (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); + bufPtr->nextRemoved += space; + copied = space; + + end = result + copied; + dst = result; + for (src = result; src < end; src++) { + curByte = *src; + if (curByte == '\r') { + statePtr->flags |= INPUT_SAW_CR; + *dst = '\n'; dst++; + } else { + if ((curByte != '\n') || + !(statePtr->flags & INPUT_SAW_CR)) { + *dst = (char) curByte; + dst++; + } + statePtr->flags &= ~INPUT_SAW_CR; } - ResetFlag(statePtr, INPUT_SAW_CR); } + copied = dst - result; + break; + } + default: { + panic("unknown eol translation mode"); } - copied = dst - result; - break; - } - default: - Tcl_Panic("unknown eol translation mode"); } /* - * If an in-stream EOF character is set for this channel, check that the - * input we copied so far does not contain the EOF char. If it does, copy - * only up to and excluding that character. + * If an in-stream EOF character is set for this channel, check that + * 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. + * Set sticky EOF so that no further input is presented + * to the caller. */ - - SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + + statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); statePtr->inputEncodingFlags |= TCL_ENCODING_END; copied = i; - break; - } - } + break; + } + } } /* * If the current buffer is empty recycle it. */ - if (IsBufferEmpty(bufPtr)) { - statePtr->inQueueHead = bufPtr->nextPtr; - if (statePtr->inQueueHead == NULL) { - statePtr->inQueueTail = NULL; - } - RecycleBuffer(statePtr, bufPtr, 0); + if (bufPtr->nextRemoved == bufPtr->nextAdded) { + statePtr->inQueueHead = bufPtr->nextPtr; + if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { + statePtr->inQueueTail = (ChannelBuffer *) NULL; + } + RecycleBuffer(statePtr, bufPtr, 0); } /* - * Return the number of characters copied into the result buffer. This may - * be different from the number of bytes consumed, because of EOL - * translations. + * Return the number of characters copied into the result buffer. + * This may be different from the number of bytes consumed, because + * of EOL translations. */ return copied; @@ -9734,8 +8394,8 @@ CopyAndTranslateBuffer( * Copy at most one buffer of input to the result space. * * Results: - * Number of bytes stored in the result buffer. May return zero if no - * input is available. + * Number of bytes stored in the result buffer. May return + * zero if no input is available. * * Side effects: * Consumes buffered input. May deallocate one buffer. @@ -9744,39 +8404,39 @@ CopyAndTranslateBuffer( */ static int -CopyBuffer( - 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? */ +CopyBuffer(chanPtr, result, space) + Channel *chanPtr; /* Channel from which to read input. */ + char *result; /* Where to store the copied input. */ + int space; /* How many bytes are available in result + * to store the copied input? */ { ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */ - int bytesInBuffer; /* How many bytes are available to be copied - * in the current input buffer? */ + int bytesInBuffer; /* How many bytes are available to be + * copied in the current input buffer? */ int copied; /* How many characters were already copied - * into the destination space? */ - + * into the destination space? */ + /* - * If there is no input at all, return zero. The invariant is that either - * there is no buffer in the queue, or if the first buffer is empty, it is - * also the last buffer (and thus there is no input in the queue). Note - * also that if the buffer is empty, we don't leave it in the queue, but - * recycle it. + * If there is no input at all, return zero. The invariant is that + * either there is no buffer in the queue, or if the first buffer + * is empty, it is also the last buffer (and thus there is no + * input in the queue). Note also that if the buffer is empty, we + * don't leave it in the queue, but recycle it. */ - - if (chanPtr->inQueueHead == NULL) { - return 0; + + if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { + return 0; } bufPtr = chanPtr->inQueueHead; - bytesInBuffer = BytesLeft(bufPtr); + bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved; copied = 0; if (bytesInBuffer == 0) { - RecycleBuffer(chanPtr->state, bufPtr, 0); - chanPtr->inQueueHead = NULL; - chanPtr->inQueueTail = NULL; - return 0; + RecycleBuffer(chanPtr->state, bufPtr, 0); + chanPtr->inQueueHead = (ChannelBuffer*) NULL; + chanPtr->inQueueTail = (ChannelBuffer*) NULL; + return 0; } /* @@ -9784,29 +8444,31 @@ CopyBuffer( */ if (bytesInBuffer < space) { - space = bytesInBuffer; + space = bytesInBuffer; } - memcpy(result, RemovePoint(bufPtr), (size_t) space); + memcpy((VOID *) result, + (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); bufPtr->nextRemoved += space; copied = space; /* - * We don't care about in-stream EOF characters here as the data read here - * may still flow through one or more transformations, i.e. is not in its - * final state yet. + * We don't care about in-stream EOF characters here as the data + * read here may still flow through one or more transformations, + * i.e. is not in its final state yet. */ /* * If the current buffer is empty recycle it. */ - if (IsBufferEmpty(bufPtr)) { - chanPtr->inQueueHead = bufPtr->nextPtr; - if (chanPtr->inQueueHead == NULL) { - chanPtr->inQueueTail = NULL; - } - RecycleBuffer(chanPtr->state, bufPtr, 0); + if (bufPtr->nextRemoved == bufPtr->nextAdded) { + chanPtr->inQueueHead = bufPtr->nextPtr; + if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { + chanPtr->inQueueTail = (ChannelBuffer *) NULL; + } + RecycleBuffer(chanPtr->state, bufPtr, 0); } /* @@ -9838,28 +8500,29 @@ CopyBuffer( */ static int -DoWrite( - Channel *chanPtr, /* The channel to buffer output for. */ - const char *src, /* Data to write. */ - int srcLen) /* Number of bytes to write. */ -{ - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ - ChannelBuffer *outBufPtr; /* Current output buffer. */ - int foundNewline; /* Did we find a newline in output? */ +DoWrite(chanPtr, src, srcLen) + Channel *chanPtr; /* The channel to buffer output for. */ + CONST char *src; /* Data to write. */ + int srcLen; /* Number of bytes to write. */ +{ + ChannelState *statePtr = chanPtr->state; /* state info for channel */ + ChannelBuffer *outBufPtr; /* Current output buffer. */ + int foundNewline; /* Did we find a newline in output? */ char *dPtr; - 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. */ - int i; /* Loop index for newline search. */ - int destCopied; /* How many bytes were used in this - * destination buffer to hold the output? */ - int totalDestCopied; /* How many bytes total were copied to the - * channel buffer? */ - int srcCopied; /* How many bytes were copied from the source - * string? */ - char *destPtr; /* Where in line to copy to? */ + 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. */ + int i; /* Loop index for newline search. */ + int destCopied; /* How many bytes were used in this + * destination buffer to hold the + * output? */ + int totalDestCopied; /* How many bytes total were + * copied to the channel buffer? */ + int srcCopied; /* How many bytes were copied from + * the source string? */ + char *destPtr; /* Where in line to copy to? */ /* * If we are in network (or windows) translation mode, record the fact @@ -9867,7 +8530,7 @@ DoWrite( */ crsent = 0; - + /* * Loop filling buffers and flushing them until all output has been * consumed. @@ -9877,96 +8540,97 @@ DoWrite( totalDestCopied = 0; while (srcLen > 0) { - /* - * Make sure there is a current output buffer to accept output. - */ - - if (statePtr->curOutPtr == NULL) { - statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize); - } + + /* + * Make sure there is a current output buffer to accept output. + */ - outBufPtr = statePtr->curOutPtr; + if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { + statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize); + } - destCopied = SpaceLeft(outBufPtr); - if (destCopied > srcLen) { - destCopied = srcLen; - } + outBufPtr = statePtr->curOutPtr; - destPtr = InsertPoint(outBufPtr); - switch (statePtr->outputTranslation) { - case TCL_TRANSLATE_LF: - srcCopied = destCopied; - memcpy(destPtr, src, (size_t) destCopied); - break; - case TCL_TRANSLATE_CR: - srcCopied = destCopied; - memcpy(destPtr, 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. - */ + destCopied = outBufPtr->bufLength - outBufPtr->nextAdded; + if (destCopied > srcLen) { + destCopied = srcLen; + } + + destPtr = outBufPtr->buf + outBufPtr->nextAdded; + switch (statePtr->outputTranslation) { + case TCL_TRANSLATE_LF: + srcCopied = destCopied; + memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied); + break; + case TCL_TRANSLATE_CR: + srcCopied = destCopied; + memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied); + for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) { + if (*dPtr == '\n') { + *dPtr = '\r'; + } + } + break; + case TCL_TRANSLATE_CRLF: + for (srcCopied = 0, dPtr = destPtr, sPtr = src; + dPtr < destPtr + destCopied; + dPtr++, sPtr++, srcCopied++) { + if (*sPtr == '\n') { + if (crsent) { + *dPtr = '\n'; + crsent = 0; + } else { + *dPtr = '\r'; + crsent = 1; + sPtr--, srcCopied--; + } + } else { + *dPtr = *sPtr; + } + } + break; + case TCL_TRANSLATE_AUTO: + panic("Tcl_Write: AUTO output translation mode not supported"); + default: + panic("Tcl_Write: unknown output translation mode"); + } - outBufPtr->nextAdded += destCopied; - if (!GotFlag(statePtr, BUFFER_READY)) { - if (IsBufferFull(outBufPtr)) { - SetFlag(statePtr, BUFFER_READY); - } else if (GotFlag(statePtr, CHANNEL_LINEBUFFERED)) { - for (sPtr = src, i = 0, foundNewline = 0; - (i < srcCopied) && (!foundNewline); - i++, sPtr++) { - if (*sPtr == '\n') { - foundNewline = 1; - break; - } - } - if (foundNewline) { - SetFlag(statePtr, BUFFER_READY); - } - } else if (GotFlag(statePtr, CHANNEL_UNBUFFERED)) { - SetFlag(statePtr, BUFFER_READY); - } - } + /* + * 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. + */ - totalDestCopied += srcCopied; - src += srcCopied; - srcLen -= srcCopied; + 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 (GotFlag(statePtr, BUFFER_READY)) { - if (FlushChannel(NULL, chanPtr, 0) != 0) { - return -1; - } - } + if (statePtr->flags & BUFFER_READY) { + if (FlushChannel(NULL, chanPtr, 0) != 0) { + return -1; + } + } } /* Closes "while" */ return totalDestCopied; @@ -9977,9 +8641,9 @@ DoWrite( * * CopyEventProc -- * - * This routine is invoked as a channel event handler for the background - * copy operation. It is just a trivial wrapper around the CopyData - * routine. + * This routine is invoked as a channel event handler for + * the background copy operation. It is just a trivial wrapper + * around the CopyData routine. * * Results: * None. @@ -9991,11 +8655,11 @@ DoWrite( */ static void -CopyEventProc( - ClientData clientData, - int mask) +CopyEventProc(clientData, mask) + ClientData clientData; + int mask; { - (void) CopyData(clientData, mask); + (void) CopyData((CopyState *)clientData, mask); } /* @@ -10009,15 +8673,15 @@ CopyEventProc( * None. * * Side effects: - * Removes any pending channel handlers and restores the blocking and - * buffering modes of the channels. The CopyState is freed. + * Removes any pending channel handlers and restores the blocking + * and buffering modes of the channels. The CopyState is freed. * *---------------------------------------------------------------------- */ static void -StopCopy( - CopyState *csPtr) /* State for bg copy to stop . */ +StopCopy(csPtr) + CopyState *csPtr; /* State for bg copy to stop . */ { ChannelState *inStatePtr, *outStatePtr; int nonBlocking; @@ -10026,41 +8690,41 @@ StopCopy( 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. */ - nonBlocking = csPtr->readFlags & CHANNEL_NONBLOCKING; + nonBlocking = (csPtr->readFlags & CHANNEL_NONBLOCKING); if (nonBlocking != (inStatePtr->flags & CHANNEL_NONBLOCKING)) { SetBlockMode(NULL, csPtr->readPtr, nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); } if (csPtr->readPtr != csPtr->writePtr) { - nonBlocking = csPtr->writeFlags & CHANNEL_NONBLOCKING; + nonBlocking = (csPtr->writeFlags & CHANNEL_NONBLOCKING); if (nonBlocking != (outStatePtr->flags & CHANNEL_NONBLOCKING)) { SetBlockMode(NULL, csPtr->writePtr, nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); } } - ResetFlag(outStatePtr, CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); + outStatePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); outStatePtr->flags |= - csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); + csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); if (csPtr->cmdPtr) { - Tcl_DeleteChannelHandler((Tcl_Channel) csPtr->readPtr, CopyEventProc, - csPtr); + Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->readPtr, CopyEventProc, + (ClientData)csPtr); if (csPtr->readPtr != csPtr->writePtr) { - Tcl_DeleteChannelHandler((Tcl_Channel) csPtr->writePtr, - CopyEventProc, csPtr); + Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr, + CopyEventProc, (ClientData)csPtr); } - TclDecrRefCount(csPtr->cmdPtr); + Tcl_DecrRefCount(csPtr->cmdPtr); } - inStatePtr->csPtrR = NULL; + inStatePtr->csPtrR = NULL; outStatePtr->csPtrW = NULL; - ckfree(csPtr); + ckfree((char*) csPtr); } /* @@ -10068,23 +8732,23 @@ StopCopy( * * StackSetBlockMode -- * - * This function sets the blocking mode for a channel, iterating through - * each channel in a stack and updates the state flags. + * This function sets the blocking mode for a channel, iterating + * through each channel in a stack and updates the state flags. * * Results: * 0 if OK, result code from failed blockModeProc otherwise. * * Side effects: - * Modifies the blocking mode of the channel and possibly generates an - * error. + * Modifies the blocking mode of the channel and possibly generates + * an error. * *---------------------------------------------------------------------- */ static int -StackSetBlockMode( - Channel *chanPtr, /* Channel to modify. */ - int mode) /* One of TCL_MODE_BLOCKING or +StackSetBlockMode(chanPtr, mode) + Channel *chanPtr; /* Channel to modify. */ + int mode; /* One of TCL_MODE_BLOCKING or * TCL_MODE_NONBLOCKING. */ { int result = 0; @@ -10095,10 +8759,10 @@ StackSetBlockMode( */ chanPtr = chanPtr->state->topChanPtr; - while (chanPtr != NULL) { + while (chanPtr != (Channel *) NULL) { blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr); if (blockModeProc != NULL) { - result = blockModeProc(chanPtr->instanceData, mode); + result = (*blockModeProc) (chanPtr->instanceData, mode); if (result != 0) { Tcl_SetErrno(result); return result; @@ -10114,64 +8778,41 @@ StackSetBlockMode( * * SetBlockMode -- * - * This function sets the blocking mode for a channel and updates the - * state flags. + * This function sets the blocking mode for a channel and updates + * the state flags. * * Results: * A standard Tcl result. * * Side effects: - * Modifies the blocking mode of the channel and possibly generates an - * error. + * Modifies the blocking mode of the channel and possibly generates + * an error. * *---------------------------------------------------------------------- */ static int -SetBlockMode( - Tcl_Interp *interp, /* Interp for error reporting. */ - Channel *chanPtr, /* Channel to modify. */ - int mode) /* One of TCL_MODE_BLOCKING or +SetBlockMode(interp, chanPtr, mode) + Tcl_Interp *interp; /* Interp for error reporting. */ + Channel *chanPtr; /* Channel to modify. */ + int mode; /* One of TCL_MODE_BLOCKING or * TCL_MODE_NONBLOCKING. */ { + ChannelState *statePtr = chanPtr->state; /* state info for channel */ int result = 0; - ChannelState *statePtr = chanPtr->state; - /* State info for channel */ result = StackSetBlockMode(chanPtr, mode); if (result != 0) { - if (interp != NULL) { - /* - * TIP #219. - * Move error messages put by the driver into the bypass area and - * put them into the regular interpreter result. Fall back to the - * regular message if nothing was found in the bypass. - * - * Note that we cannot have a message in the interpreter bypass - * area, StackSetBlockMode is restricted to the channel bypass. - * We still need the interp as the destination of the move. - */ - - if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) { - Tcl_AppendResult(interp, "error setting blocking mode: ", - Tcl_PosixError(interp), NULL); - } - } else { - /* - * TIP #219. - * If we have no interpreter to put a bypass message into we have - * to clear it, to prevent its propagation and use in other places - * unrelated to the actual occurence of the problem. - */ - - Tcl_SetChannelError((Tcl_Channel) chanPtr, NULL); + if (interp != (Tcl_Interp *) NULL) { + Tcl_AppendResult(interp, "error setting blocking mode: ", + Tcl_PosixError(interp), (char *) NULL); } return TCL_ERROR; } if (mode == TCL_MODE_BLOCKING) { - ResetFlag(statePtr, CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED); + statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED)); } else { - SetFlag(statePtr, CHANNEL_NONBLOCKING); + statePtr->flags |= CHANNEL_NONBLOCKING; } return TCL_OK; } @@ -10193,10 +8834,10 @@ SetBlockMode( */ int -Tcl_GetChannelNames( - Tcl_Interp *interp) /* Interp for error reporting. */ +Tcl_GetChannelNames(interp) + Tcl_Interp *interp; /* Interp for error reporting. */ { - return Tcl_GetChannelNamesEx(interp, NULL); + return Tcl_GetChannelNamesEx(interp, (char *) NULL); } /* @@ -10204,9 +8845,9 @@ Tcl_GetChannelNames( * * Tcl_GetChannelNamesEx -- * - * Return the names of open channels in the interp filtered filtered - * through a pattern. If pattern is NULL, it returns all the open - * channels. + * Return the names of open channels in the interp filtered + * filtered through a pattern. If pattern is NULL, it returns + * all the open channels. * * Results: * TCL_OK or TCL_ERROR. @@ -10218,45 +8859,35 @@ Tcl_GetChannelNames( */ int -Tcl_GetChannelNamesEx( - Tcl_Interp *interp, /* Interp for error reporting. */ - const char *pattern) /* Pattern to filter on. */ +Tcl_GetChannelNamesEx(interp, pattern) + Tcl_Interp *interp; /* Interp for error reporting. */ + CONST char *pattern; /* pattern to filter on. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ChannelState *statePtr; - const char *name; /* Name for channel */ - Tcl_Obj *resultPtr; /* Pointer to result object */ + CONST char *name; /* name for channel */ + Tcl_Obj *resultPtr; /* pointer to result object */ Tcl_HashTable *hTblPtr; /* Hash table of channels. */ Tcl_HashEntry *hPtr; /* Search variable. */ Tcl_HashSearch hSearch; /* Search variable. */ - if (interp == NULL) { + if (interp == (Tcl_Interp *) NULL) { return TCL_OK; } /* - * Get the channel table that stores the channels registered for this - * interpreter. + * Get the channel table that stores the channels registered + * for this interpreter. */ + hTblPtr = GetChannelTable(interp); + resultPtr = Tcl_GetObjResult(interp); - hTblPtr = GetChannelTable(interp); - TclNewObj(resultPtr); - if ((pattern != NULL) && TclMatchIsTrivial(pattern) - && !((pattern[0] == 's') && (pattern[1] == 't') - && (pattern[2] == 'd'))) { - if ((Tcl_FindHashEntry(hTblPtr, pattern) != NULL) - && (Tcl_ListObjAppendElement(interp, resultPtr, - Tcl_NewStringObj(pattern, -1)) != TCL_OK)) { - goto error; - } - goto done; - } + for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); + hPtr != (Tcl_HashEntry *) NULL; + hPtr = Tcl_NextHashEntry(&hSearch)) { - for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != 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"; @@ -10264,24 +8895,18 @@ Tcl_GetChannelNamesEx( name = "stderr"; } else { /* - * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), but it's - * simpler to just grab the name from the statePtr. + * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), + * but it's simpler to just grab the name from the statePtr. */ - name = statePtr->channelName; } if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) && (Tcl_ListObjAppendElement(interp, resultPtr, Tcl_NewStringObj(name, -1)) != TCL_OK)) { - error: - TclDecrRefCount(resultPtr); return TCL_ERROR; } } - - done: - Tcl_SetObjResult(interp, resultPtr); return TCL_OK; } @@ -10290,8 +8915,8 @@ Tcl_GetChannelNamesEx( * * Tcl_IsChannelRegistered -- * - * Checks whether the channel is associated with the interp. See also - * Tcl_RegisterChannel and Tcl_UnregisterChannel. + * Checks whether the channel is associated with the interp. + * See also Tcl_RegisterChannel and Tcl_UnregisterChannel. * * Results: * 0 if the channel is not registered in the interpreter, 1 else. @@ -10303,33 +8928,32 @@ Tcl_GetChannelNamesEx( */ int -Tcl_IsChannelRegistered( - Tcl_Interp *interp, /* The interp to query of the channel */ - Tcl_Channel chan) /* The channel to check */ +Tcl_IsChannelRegistered (interp, chan) + Tcl_Interp* interp; /* The interp to query of the channel */ + Tcl_Channel chan; /* The channel to check */ { - Tcl_HashTable *hTblPtr; /* Hash table of channels. */ - Tcl_HashEntry *hPtr; /* Search variable. */ - Channel *chanPtr; /* The real IO channel. */ - ChannelState *statePtr; /* State of the real channel. */ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of the real channel. */ /* - * Always check bottom-most channel in the stack. This is the one that - * gets registered. + * Always check bottom-most channel in the stack. This is the one + * that gets registered. */ - chanPtr = ((Channel *) chan)->state->bottomChanPtr; statePtr = chanPtr->state; - hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); - if (hTblPtr == NULL) { - return 0; + hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL); + if (hTblPtr == (Tcl_HashTable *) NULL) { + return 0; } hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName); - if (hPtr == NULL) { - return 0; + if (hPtr == (Tcl_HashEntry *) NULL) { + return 0; } if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { - return 0; + return 0; } return 1; @@ -10352,11 +8976,11 @@ Tcl_IsChannelRegistered( */ int -Tcl_IsChannelShared( - 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. */ + /* State of real channel structure. */ return ((statePtr->refCount > 1) ? 1 : 0); } @@ -10367,8 +8991,8 @@ Tcl_IsChannelShared( * Tcl_IsChannelExisting -- * * Checks whether a channel of the given name exists in the - * (thread)-global list of all channels. See Tcl_GetChannelNamesEx for - * function exposed at the Tcl level. + * (thread)-global list of all channels. + * See Tcl_GetChannelNamesEx for function exposed at the Tcl level. * * Results: * A boolean value (0 = Does not exist, 1 = Does exist). @@ -10380,18 +9004,19 @@ Tcl_IsChannelShared( */ int -Tcl_IsChannelExisting( - const char *chanName) /* The name of the channel to look for. */ +Tcl_IsChannelExisting(chanName) + CONST char* chanName; /* The name of the channel to look for. */ { ChannelState *statePtr; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - const char *name; + CONST char *name; int chanNameLen; chanNameLen = strlen(chanName); - for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL; - statePtr = statePtr->nextCSPtr) { - if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { + for (statePtr = tsdPtr->firstCSPtr; + statePtr != NULL; + statePtr = statePtr->nextCSPtr) { + if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { name = "stdin"; } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) { name = "stdout"; @@ -10401,8 +9026,10 @@ Tcl_IsChannelExisting( name = statePtr->channelName; } + /* Bug 2333466. Include \0 in the compare to prevent partial matching on prefixes. + */ if ((*chanName == *name) && - (memcmp(name, chanName, (size_t) chanNameLen + 1) == 0)) { + (memcmp(name, chanName, (size_t) chanNameLen+1) == 0)) { return 1; } } @@ -10426,9 +9053,9 @@ Tcl_IsChannelExisting( *---------------------------------------------------------------------- */ -const char * -Tcl_ChannelName( - const Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */ +CONST char * +Tcl_ChannelName(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->typeName; } @@ -10450,9 +9077,8 @@ Tcl_ChannelName( */ Tcl_ChannelTypeVersion -Tcl_ChannelVersion( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelVersion(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) { return TCL_CHANNEL_VERSION_2; @@ -10460,14 +9086,11 @@ Tcl_ChannelVersion( return TCL_CHANNEL_VERSION_3; } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_4) { return TCL_CHANNEL_VERSION_4; - } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_5) { - return TCL_CHANNEL_VERSION_5; } else { /* - * In <v2 channel versions, the version field is occupied by the - * Tcl_DriverBlockModeProc + * In <v2 channel versions, the version field is occupied + * by the Tcl_DriverBlockModeProc */ - return TCL_CHANNEL_VERSION_1; } } @@ -10490,13 +9113,13 @@ Tcl_ChannelVersion( */ static int -HaveVersion( - const Tcl_ChannelType *chanTypePtr, - Tcl_ChannelTypeVersion minimumVersion) +HaveVersion(chanTypePtr, minimumVersion) + Tcl_ChannelType *chanTypePtr; + Tcl_ChannelTypeVersion minimumVersion; { Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr); - return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion)); + return ((int)actualVersion) >= ((int)minimumVersion); } /* @@ -10515,19 +9138,17 @@ HaveVersion( *---------------------------------------------------------------------- */ Tcl_DriverBlockModeProc * -Tcl_ChannelBlockModeProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelBlockModeProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { return chanTypePtr->blockModeProc; + } else { + /* + * The v1 structure had the blockModeProc in a different place. + */ + return (Tcl_DriverBlockModeProc *) (chanTypePtr->version); } - - /* - * The v1 structure had the blockModeProc in a different place. - */ - - return (Tcl_DriverBlockModeProc *) chanTypePtr->version; } /* @@ -10547,9 +9168,8 @@ Tcl_ChannelBlockModeProc( */ Tcl_DriverCloseProc * -Tcl_ChannelCloseProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelCloseProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->closeProc; } @@ -10571,9 +9191,8 @@ Tcl_ChannelCloseProc( */ Tcl_DriverClose2Proc * -Tcl_ChannelClose2Proc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelClose2Proc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->close2Proc; } @@ -10595,9 +9214,8 @@ Tcl_ChannelClose2Proc( */ Tcl_DriverInputProc * -Tcl_ChannelInputProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelInputProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->inputProc; } @@ -10619,9 +9237,8 @@ Tcl_ChannelInputProc( */ Tcl_DriverOutputProc * -Tcl_ChannelOutputProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelOutputProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->outputProc; } @@ -10643,9 +9260,8 @@ Tcl_ChannelOutputProc( */ Tcl_DriverSeekProc * -Tcl_ChannelSeekProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelSeekProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->seekProc; } @@ -10667,9 +9283,8 @@ Tcl_ChannelSeekProc( */ Tcl_DriverSetOptionProc * -Tcl_ChannelSetOptionProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelSetOptionProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->setOptionProc; } @@ -10691,9 +9306,8 @@ Tcl_ChannelSetOptionProc( */ Tcl_DriverGetOptionProc * -Tcl_ChannelGetOptionProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelGetOptionProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->getOptionProc; } @@ -10715,9 +9329,8 @@ Tcl_ChannelGetOptionProc( */ Tcl_DriverWatchProc * -Tcl_ChannelWatchProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelWatchProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->watchProc; } @@ -10739,9 +9352,8 @@ Tcl_ChannelWatchProc( */ Tcl_DriverGetHandleProc * -Tcl_ChannelGetHandleProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelGetHandleProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { return chanTypePtr->getHandleProc; } @@ -10763,14 +9375,14 @@ Tcl_ChannelGetHandleProc( */ Tcl_DriverFlushProc * -Tcl_ChannelFlushProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelFlushProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { return chanTypePtr->flushProc; + } else { + return NULL; } - return NULL; } /* @@ -10790,14 +9402,14 @@ Tcl_ChannelFlushProc( */ Tcl_DriverHandlerProc * -Tcl_ChannelHandlerProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelHandlerProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { return chanTypePtr->handlerProc; + } else { + return NULL; } - return NULL; } /* @@ -10817,14 +9429,14 @@ Tcl_ChannelHandlerProc( */ Tcl_DriverWideSeekProc * -Tcl_ChannelWideSeekProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelWideSeekProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) { return chanTypePtr->wideSeekProc; + } else { + return NULL; } - return NULL; } /* @@ -10832,8 +9444,7 @@ Tcl_ChannelWideSeekProc( * * Tcl_ChannelThreadActionProc -- * - * TIP #218, Channel Thread Actions. Return the - * Tcl_DriverThreadActionProc of the channel type. + * Return the Tcl_DriverThreadActionProc of the channel type. * * Results: * A pointer to the proc. @@ -10845,552 +9456,52 @@ Tcl_ChannelWideSeekProc( */ Tcl_DriverThreadActionProc * -Tcl_ChannelThreadActionProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ +Tcl_ChannelThreadActionProc(chanTypePtr) + Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */ { if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) { return chanTypePtr->threadActionProc; - } - return NULL; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_SetChannelErrorInterp -- - * - * TIP #219, Tcl Channel Reflection API. - * Store an error message for the I/O system. - * - * Results: - * None. - * - * Side effects: - * Discards a previously stored message. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_SetChannelErrorInterp( - Tcl_Interp *interp, /* Interp to store the data into. */ - Tcl_Obj *msg) /* Error message to store. */ -{ - Interp *iPtr = (Interp *) interp; - - if (iPtr->chanMsg != NULL) { - TclDecrRefCount(iPtr->chanMsg); - iPtr->chanMsg = NULL; - } - - if (msg != NULL) { - iPtr->chanMsg = FixLevelCode(msg); - Tcl_IncrRefCount(iPtr->chanMsg); - } - return; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_SetChannelError -- - * - * TIP #219, Tcl Channel Reflection API. - * Store an error message for the I/O system. - * - * Results: - * None. - * - * Side effects: - * Discards a previously stored message. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_SetChannelError( - Tcl_Channel chan, /* Channel to store the data into. */ - Tcl_Obj *msg) /* Error message to store. */ -{ - ChannelState *statePtr = ((Channel *) chan)->state; - - if (statePtr->chanMsg != NULL) { - TclDecrRefCount(statePtr->chanMsg); - statePtr->chanMsg = NULL; - } - - if (msg != NULL) { - statePtr->chanMsg = FixLevelCode(msg); - Tcl_IncrRefCount(statePtr->chanMsg); - } - return; -} - -/* - *---------------------------------------------------------------------- - * - * FixLevelCode -- - * - * TIP #219, Tcl Channel Reflection API. - * Scans an error message for bad -code / -level directives. Returns a - * modified copy with such directives corrected, and the input if it had - * no problems. - * - * Results: - * A Tcl_Obj* - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -static Tcl_Obj * -FixLevelCode( - Tcl_Obj *msg) -{ - int explicitResult, numOptions, lc, lcn; - Tcl_Obj **lv, **lvn; - int res, i, j, val, lignore, cignore; - int newlevel = -1, newcode = -1; - - /* ASSERT msg != NULL */ - - /* - * Process the caught message. - * - * Syntax = (option value)... ?message? - * - * Bad message syntax causes a panic, because the other side uses - * Tcl_GetReturnOptions and list construction functions to marshall the - * information. Hence an error means that we've got serious breakage. - */ - - res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv); - if (res != TCL_OK) { - Tcl_Panic("Tcl_SetChannelError: bad syntax of message"); - } - - explicitResult = (1 == (lc % 2)); - numOptions = lc - explicitResult; - - /* - * No options, nothing to do. - */ - - if (numOptions == 0) { - return msg; - } - - /* - * Check for -code x, x != 1|error, and -level x, x != 0 - */ - - for (i = 0; i < numOptions; i += 2) { - if (0 == strcmp(TclGetString(lv[i]), "-code")) { - /* - * !"error", !integer, integer != 1 (numeric code for error) - */ - - res = TclGetIntFromObj(NULL, lv[i+1], &val); - if (((res == TCL_OK) && (val != 1)) || ((res != TCL_OK) && - (0 != strcmp(TclGetString(lv[i+1]), "error")))) { - newcode = 1; - } - } else if (0 == strcmp(TclGetString(lv[i]), "-level")) { - /* - * !integer, integer != 0 - */ - - res = TclGetIntFromObj(NULL, lv [i+1], &val); - if ((res != TCL_OK) || (val != 0)) { - newlevel = 0; - } - } - } - - /* - * -code, -level are either not present or ok. Nothing to do. - */ - - if ((newlevel < 0) && (newcode < 0)) { - return msg; - } - - lcn = numOptions; - if (explicitResult) { - lcn ++; - } - if (newlevel >= 0) { - lcn += 2; - } - if (newcode >= 0) { - lcn += 2; - } - - lvn = ckalloc(lcn * sizeof(Tcl_Obj *)); - - /* - * New level/code information is spliced into the first occurence of - * -level, -code, further occurences are ignored. The options cannot be - * not present, we would not come here. Options which are ok are simply - * copied over. - */ - - lignore = cignore = 0; - for (i=0, j=0; i<numOptions; i+=2) { - if (0 == strcmp(TclGetString(lv[i]), "-level")) { - if (newlevel >= 0) { - lvn[j++] = lv[i]; - lvn[j++] = Tcl_NewIntObj(newlevel); - newlevel = -1; - lignore = 1; - continue; - } else if (lignore) { - continue; - } - } else if (0 == strcmp(TclGetString(lv[i]), "-code")) { - if (newcode >= 0) { - lvn[j++] = lv[i]; - lvn[j++] = Tcl_NewIntObj(newcode); - newcode = -1; - cignore = 1; - continue; - } else if (cignore) { - continue; - } - } - - /* - * Keep everything else, possibly copied down. - */ - - lvn[j++] = lv[i]; - lvn[j++] = lv[i+1]; - } - if (newlevel >= 0) { - Tcl_Panic("Defined newlevel not used in rewrite"); - } - if (newcode >= 0) { - Tcl_Panic("Defined newcode not used in rewrite"); - } - - if (explicitResult) { - lvn[j++] = lv[i]; - } - - msg = Tcl_NewListObj(j, lvn); - - ckfree(lvn); - return msg; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_GetChannelErrorInterp -- - * - * TIP #219, Tcl Channel Reflection API. - * Return the message stored by the channel driver. - * - * Results: - * Tcl error message object. - * - * Side effects: - * Resets the stored data to NULL. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_GetChannelErrorInterp( - Tcl_Interp *interp, /* Interp to query. */ - Tcl_Obj **msg) /* Place for error message. */ -{ - Interp *iPtr = (Interp *) interp; - - *msg = iPtr->chanMsg; - iPtr->chanMsg = NULL; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_GetChannelError -- - * - * TIP #219, Tcl Channel Reflection API. - * Return the message stored by the channel driver. - * - * Results: - * Tcl error message object. - * - * Side effects: - * Resets the stored data to NULL. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_GetChannelError( - Tcl_Channel chan, /* Channel to query. */ - Tcl_Obj **msg) /* Place for error message. */ -{ - ChannelState *statePtr = ((Channel *) chan)->state; - - *msg = statePtr->chanMsg; - statePtr->chanMsg = NULL; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_ChannelTruncateProc -- - * - * TIP #208 (subsection relating to truncation, based on TIP #206). - * Return the Tcl_DriverTruncateProc of the channel type. - * - * Results: - * A pointer to the proc. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -Tcl_DriverTruncateProc * -Tcl_ChannelTruncateProc( - const Tcl_ChannelType *chanTypePtr) - /* Pointer to channel type. */ -{ - if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) { - return chanTypePtr->truncateProc; - } - return NULL; -} - -/* - *---------------------------------------------------------------------- - * - * DupChannelIntRep -- - * - * Initialize the internal representation of a new Tcl_Obj to a copy of - * the internal representation of an existing string object. - * - * Results: - * None. - * - * Side effects: - * copyPtr's internal rep is set to a copy of srcPtr's internal - * representation. - * - *---------------------------------------------------------------------- - */ - -static void -DupChannelIntRep( - register Tcl_Obj *srcPtr, /* Object with internal rep to copy. Must have - * an internal rep of type "Channel". */ - register Tcl_Obj *copyPtr) /* Object with internal rep to set. Must not - * currently have an internal rep.*/ -{ - ChannelState *statePtr = GET_CHANNELSTATE(srcPtr); - Interp *interpPtr = GET_CHANNELINTERP(srcPtr); - - SET_CHANNELSTATE(copyPtr, statePtr); - SET_CHANNELINTERP(copyPtr, interpPtr); - Tcl_Preserve(statePtr); - copyPtr->typePtr = &tclChannelType; -} - -/* - *---------------------------------------------------------------------- - * - * SetChannelFromAny -- - * - * Create an internal representation of type "Channel" for an object. - * - * Results: - * This operation always succeeds and returns TCL_OK. - * - * Side effects: - * Any old internal reputation for objPtr is freed and the internal - * representation is set to "Channel". - * - *---------------------------------------------------------------------- - */ - -static int -SetChannelFromAny( - Tcl_Interp *interp, /* Used for error reporting if not NULL. */ - register Tcl_Obj *objPtr) /* The object to convert. */ -{ - ChannelState *statePtr; - Interp *interpPtr; - - if (interp == NULL) { - return TCL_ERROR; - } - if (objPtr->typePtr == &tclChannelType) { - /* - * The channel is valid until any call to DetachChannel occurs. - * Ensure consistency checks are done. - */ - - statePtr = GET_CHANNELSTATE(objPtr); - interpPtr = GET_CHANNELINTERP(objPtr); - if (GotFlag(statePtr, CHANNEL_TAINTED|CHANNEL_CLOSED)) { - ResetFlag(statePtr, CHANNEL_TAINTED); - Tcl_Release(statePtr); - UpdateStringOfChannel(objPtr); - objPtr->typePtr = NULL; - } else if (interpPtr != (Interp*) interp) { - Tcl_Release(statePtr); - UpdateStringOfChannel(objPtr); - objPtr->typePtr = NULL; - } - } - if (objPtr->typePtr != &tclChannelType) { - Tcl_Channel chan; - - /* - * We need a valid string with which to check for a valid channel, but - * make sure not to free internal rep until validated. [Bug 1847044] - */ - - if ((objPtr->typePtr != NULL) && (objPtr->bytes == NULL)) { - objPtr->typePtr->updateStringProc(objPtr); - } - - chan = Tcl_GetChannel(interp, objPtr->bytes, NULL); - if (chan == NULL) { - return TCL_ERROR; - } - - TclFreeIntRep(objPtr); - statePtr = ((Channel *) chan)->state; - Tcl_Preserve(statePtr); - SET_CHANNELSTATE(objPtr, statePtr); - SET_CHANNELINTERP(objPtr, interp); - objPtr->typePtr = &tclChannelType; - } - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * UpdateStringOfChannel -- - * - * Update the string representation for an object whose internal - * representation is "Channel". - * - * Results: - * None. - * - * Side effects: - * The object's string may be set by converting its Unicode represention - * to UTF format. - * - *---------------------------------------------------------------------- - */ - -static void -UpdateStringOfChannel( - Tcl_Obj *objPtr) /* Object with string rep to update. */ -{ - if (objPtr->bytes == NULL) { - ChannelState *statePtr = GET_CHANNELSTATE(objPtr); - const char *name = statePtr->channelName; - - if (name) { - size_t len = strlen(name); - - objPtr->bytes = ckalloc(len + 1); - objPtr->length = len; - memcpy(objPtr->bytes, name, len); - } else { - objPtr->bytes = tclEmptyStringRep; - objPtr->length = 0; - } + } else { + return NULL; } } - -/* - *---------------------------------------------------------------------- - * - * FreeChannelIntRep -- - * - * Release statePtr storage. - * - * Results: - * None. - * - * Side effects: - * May cause state to be freed. - * - *---------------------------------------------------------------------- - */ -static void -FreeChannelIntRep( - Tcl_Obj *objPtr) /* Object with internal rep to free. */ -{ - Tcl_Release(GET_CHANNELSTATE(objPtr)); - objPtr->typePtr = NULL; -} - #if 0 -/* - * For future debugging work, a simple function to print the flags of a - * channel in semi-readable form. +/* For future debugging work, a simple function to print the flags of + * a channel in semi-readable form. */ static int -DumpFlags( - char *str, - int flags) -{ - char buf[20]; - int i = 0; - -#define ChanFlag(chr, bit) (buf[i++] = ((flags & (bit)) ? (chr) : '_')) - - ChanFlag('r', TCL_READABLE); - ChanFlag('w', TCL_WRITABLE); - ChanFlag('n', CHANNEL_NONBLOCKING); - ChanFlag('l', CHANNEL_LINEBUFFERED); - ChanFlag('u', CHANNEL_UNBUFFERED); - ChanFlag('R', BUFFER_READY); - ChanFlag('F', BG_FLUSH_SCHEDULED); - ChanFlag('c', CHANNEL_CLOSED); - ChanFlag('E', CHANNEL_EOF); - ChanFlag('S', CHANNEL_STICKY_EOF); - ChanFlag('B', CHANNEL_BLOCKED); - ChanFlag('/', INPUT_SAW_CR); - ChanFlag('*', INPUT_NEED_NL); - ChanFlag('D', CHANNEL_DEAD); - ChanFlag('R', CHANNEL_RAW_MODE); +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++; #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - ChanFlag('T', CHANNEL_TIMER_FEV); - ChanFlag('H', CHANNEL_HAS_MORE_DATA); + 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++; #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - ChanFlag('x', CHANNEL_INCLOSE); - - buf[i] ='\0'; + if (flags & CHANNEL_INCLOSE) {buf[i] = 'x';} else {buf [i]='_';}; i++; + buf [i] ='\0'; - fprintf(stderr, "%s: %s\n", str, buf); - return 0; + fprintf (stderr,"%s: %s\n", str, buf); fflush(stderr); + return 0; } #endif - -/* - * Local Variables: - * mode: c - * c-basic-offset: 4 - * fill-column: 78 - * tab-width: 8 - * indent-tabs-mode: nil - * End: - */ |