diff options
Diffstat (limited to 'generic/tclIO.c')
| -rw-r--r-- | generic/tclIO.c | 3183 |
1 files changed, 1564 insertions, 1619 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c index 0766e19..e11f489 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 @@ -10,59 +10,47 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIO.c,v 1.90 2005/06/22 19:47:43 kennykb Exp $ + * RCS: @(#) $Id: tclIO.c,v 1.91 2005/07/17 21:17:40 dkf Exp $ */ #include "tclInt.h" #include "tclIO.h" #include <assert.h> - /* - * All static variables used in this file are collected into a single - * instance of the following structure. For multi-threaded implementations, - * 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; - - /* - * List of all channels currently open, indexed by ChannelState, - * as only one ChannelState exists per set of stacked channels. - */ - ChannelState *firstCSPtr; - + /* 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. */ #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; + int channelExitHandlerCreated; /* Has a channel exit handler been + * created yet? */ + int channelEventSourceCreated; /* Has the channel event source been + * created and registered with the + * notifier? */ #endif - - /* - * Static variables to hold channels for stdin, stdout and stderr. - */ - Tcl_Channel stdinChannel; + Tcl_Channel stdinChannel; /* Static variable for the stdin + * channel. */ int stdinInitialized; - Tcl_Channel stdoutChannel; + Tcl_Channel stdoutChannel; /* Static variable for the stdout + * channel. */ int stdoutInitialized; - Tcl_Channel stderrChannel; + Tcl_Channel stderrChannel; /* Static variable for the stderr + * channel. */ int stderrInitialized; - } ThreadSpecificData; static Tcl_ThreadDataKey dataKey; @@ -155,7 +143,7 @@ static int WriteChars _ANSI_ARGS_((Channel *chanPtr, * TclInitIOSubsystem -- * * Initialize all resources used by this subsystem on a per-process - * basis. + * basis. * * Results: * None. @@ -170,20 +158,21 @@ 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-process basis. + * Closes all extant channels that have not already been closed because + * they were not owned by any interp. * * Results: * None. @@ -209,8 +198,8 @@ TclFinalizeIOSubsystem() nextCSPtr = statePtr->nextCSPtr; /* - * Set the channel back into blocking mode to ensure that we wait - * for all data to flush out. + * 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, @@ -219,27 +208,24 @@ TclFinalizeIOSubsystem() if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || (chanPtr == (Channel *) tsdPtr->stdoutChannel) || (chanPtr == (Channel *) tsdPtr->stderrChannel)) { - /* - * Decrement the refcount which was earlier artificially bumped - * up to keep the channel from being closed. + * Decrement the refcount which was earlier artificially bumped up + * to keep the channel from being closed. */ statePtr->refCount--; } if (statePtr->refCount <= 0) { - /* * Close it only if the refcount indicates that the channel is not - * referenced from any interpreter. If it is, that interpreter will - * close the channel when it gets destroyed. + * referenced from any interpreter. If it is, that interpreter + * will close the channel when it gets destroyed. */ (void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else { - /* * The refcount is greater than zero, so flush the channel. */ @@ -247,8 +233,8 @@ TclFinalizeIOSubsystem() Tcl_Flush((Tcl_Channel) chanPtr); /* - * Call the device driver to actually close the underlying - * device for this channel. + * Call the device driver to actually close the underlying device + * for this channel. */ if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { @@ -278,8 +264,8 @@ TclFinalizeIOSubsystem() * * 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 @@ -297,18 +283,18 @@ Tcl_SetStdChannel(channel, type) { 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; } } @@ -323,8 +309,7 @@ Tcl_SetStdChannel(channel, type) * 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. * *---------------------------------------------------------------------- */ @@ -337,54 +322,54 @@ Tcl_GetStdChannel(type) 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; + 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. - */ + /* + * 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); - } + 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->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->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; + } + channel = tsdPtr->stderrChannel; + break; } return channel; } @@ -401,20 +386,20 @@ Tcl_GetStdChannel(type) * 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(chan, proc, clientData) - Tcl_Channel chan; /* The channel for which to create the - * close callback. */ + 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. */ + ClientData clientData; /* Arbitrary data to pass to the close + * callback. */ { ChannelState *statePtr; CloseCallback *cbPtr; @@ -434,28 +419,27 @@ Tcl_CreateCloseHandler(chan, proc, clientData) * * 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(chan, proc, clientData) - Tcl_Channel chan; /* The channel for which to cancel the - * close callback. */ + 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. */ + ClientData clientData; /* The callback data for the callback to + * remove. */ { ChannelState *statePtr; CloseCallback *cbPtr, *cbPrevPtr; @@ -481,17 +465,16 @@ Tcl_DeleteCloseHandler(chan, proc, clientData) * * 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. * *---------------------------------------------------------------------- */ @@ -513,9 +496,8 @@ GetChannelTable(interp) (ClientData) hTblPtr); /* - * If the interpreter is trusted (not "safe"), insert channels - * for stdin, stdout and stderr (possibly creating them in the - * process). + * 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) { @@ -542,9 +524,8 @@ GetChannelTable(interp) * 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. @@ -568,7 +549,7 @@ DeleteChannelTable(clientData, interp) Channel *chanPtr; /* Channel being deleted. */ ChannelState *statePtr; /* State of Channel being deleted. */ EventScriptRecord *sPtr, *prevPtr, *nextPtr; - /* Variables to loop over all channel events + /* Variables to loop over all channel events * registered, to delete the ones that refer * to the interpreter being deleted. */ @@ -613,9 +594,9 @@ DeleteChannelTable(clientData, interp) /* * 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_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); @@ -636,11 +617,11 @@ DeleteChannelTable(clientData, interp) * 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. @@ -700,13 +681,13 @@ CheckForStdChannelsBeingClosed(chan) *---------------------------------------------------------------------- */ -int +int Tcl_IsStandardChannel(chan) Tcl_Channel chan; /* Channel to check. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); - if ((chan == tsdPtr->stdinChannel) + if ((chan == tsdPtr->stdinChannel) || (chan == tsdPtr->stdoutChannel) || (chan == tsdPtr->stderrChannel)) { return 1; @@ -721,8 +702,8 @@ Tcl_IsStandardChannel(chan) * 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. @@ -781,17 +762,17 @@ Tcl_RegisterChannel(interp, chan) * If the interpreter given as argument is NULL, it only decrements the * 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. * @@ -838,8 +819,8 @@ Tcl_UnregisterChannel(interp, chan) if (statePtr->refCount <= 0) { /* - * Ensure that if there is another buffer, it gets flushed - * whether or not we are doing a background flush. + * Ensure that if there is another buffer, it gets flushed whether or + * not we are doing a background flush. */ if ((statePtr->curOutPtr != NULL) && @@ -849,7 +830,10 @@ Tcl_UnregisterChannel(interp, chan) } Tcl_Preserve((ClientData)statePtr); if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { - /* We don't want to re-enter Tcl_Close */ + /* + * We don't want to re-enter Tcl_Close(). + */ + if (!(statePtr->flags & CHANNEL_CLOSED)) { if (Tcl_Close(interp, chan) != TCL_OK) { statePtr->flags |= CHANNEL_CLOSED; @@ -871,32 +855,29 @@ Tcl_UnregisterChannel(interp, chan) * * 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. + * 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. * *---------------------------------------------------------------------- */ @@ -920,20 +901,18 @@ Tcl_DetachChannel(interp, chan) * * 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. + * 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. * *---------------------------------------------------------------------- */ @@ -972,10 +951,10 @@ DetachChannel(interp, chan) Tcl_DeleteHashEntry(hPtr); /* - * 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. */ @@ -997,9 +976,9 @@ DetachChannel(interp, chan) * 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. @@ -1009,8 +988,8 @@ DetachChannel(interp, chan) Tcl_Channel Tcl_GetChannel(interp, chanName, modePtr) - Tcl_Interp *interp; /* Interpreter in which to find or create - * the channel. */ + 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 @@ -1023,11 +1002,11 @@ Tcl_GetChannel(interp, chanName, modePtr) 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; @@ -1054,10 +1033,9 @@ Tcl_GetChannel(interp, chanName, modePtr) } /* - * 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 = (Channel *) Tcl_GetHashValue(hPtr); @@ -1074,15 +1052,13 @@ Tcl_GetChannel(interp, chanName, modePtr) * * 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. * *---------------------------------------------------------------------- */ @@ -1092,12 +1068,12 @@ 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. */ + 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. */ + ChannelState *statePtr; /* The stack-level independent state info for + * the channel. */ CONST char *name; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); @@ -1106,16 +1082,16 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) * 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*)); /* - * 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 = (Channel *) ckalloc((unsigned) sizeof(Channel)); @@ -1143,18 +1119,17 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, 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. + * 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; @@ -1162,11 +1137,11 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) 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; @@ -1197,7 +1172,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) } /* - * 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; @@ -1209,31 +1184,30 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) /* * 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 = (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)) { + if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN); Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); } else if ((tsdPtr->stdoutChannel == NULL) && @@ -1244,7 +1218,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) (tsdPtr->stderrInitialized == 1)) { Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR); Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); - } + } return (Tcl_Channel) chanPtr; } @@ -1253,26 +1227,24 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask) * * 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. * *---------------------------------------------------------------------- */ @@ -1284,8 +1256,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) * channel. */ ClientData instanceData; /* Instance specific data for the new * channel. */ - int mask; /* TCL_READABLE & TCL_WRITABLE to indicate - * if the channel is readable, writable. */ + 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); @@ -1293,8 +1265,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) ChannelState *statePtr; /* - * Find the given channel in the list of all channels. - * If we don't find it, then it was never registered correctly. + * 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. */ @@ -1313,15 +1285,15 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) } /* - * 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 - * W | | | + | + | restrict the capabilities of the - * RW| | + | + | + | superceded one ! + * R | | + | | + | The superceding channel is allowed to restrict + * W | | | + | + | the capabilities of the superceded one! + * RW| | + | + | + | * --+---+---+---+----+ */ @@ -1333,10 +1305,10 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) } /* - * 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) { @@ -1355,26 +1327,25 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) statePtr->csPtr = csPtr; } /* - * 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 != (ChannelBuffer *) NULL)) { /* - * Remark: It is possible that the channel buffers contain - * data from some earlier push-backs. + * Remark: It is possible that the channel buffers contain data from + * some earlier push-backs. */ statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead; @@ -1391,8 +1362,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) 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: */ @@ -1421,15 +1392,15 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) * * 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. + * If TCL_ERROR is returned, the posix error code will be set with + * Tcl_SetErrno. * *---------------------------------------------------------------------- */ @@ -1460,10 +1431,10 @@ Tcl_UnstackChannel(interp, chan) 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. */ @@ -1485,13 +1456,13 @@ Tcl_UnstackChannel(interp, chan) } /* - * 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 (((statePtr->flags & TCL_READABLE) != 0) && @@ -1550,8 +1521,8 @@ Tcl_UnstackChannel(interp, chan) } } 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) { @@ -1572,9 +1543,9 @@ Tcl_UnstackChannel(interp, chan) * 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. @@ -1599,9 +1570,9 @@ Tcl_GetStackedChannel(chan) * 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. @@ -1648,8 +1619,7 @@ Tcl_GetChannelInstanceData(chan) * * 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. @@ -1662,7 +1632,8 @@ Tcl_GetChannelInstanceData(chan) Tcl_ThreadId Tcl_GetChannelThread(chan) - Tcl_Channel chan; /* The channel to return managing thread for. */ + Tcl_Channel chan; /* The channel to return managing thread + * for. */ { Channel *chanPtr = (Channel *) chan; /* The actual channel. */ @@ -1689,7 +1660,8 @@ 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; } @@ -1699,8 +1671,8 @@ Tcl_GetChannelType(chan) * * 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. @@ -1713,11 +1685,11 @@ Tcl_GetChannelType(chan) int Tcl_GetChannelMode(chan) - Tcl_Channel chan; /* The channel for which the mode is - * being computed. */ + 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)); } @@ -1730,9 +1702,8 @@ Tcl_GetChannelMode(chan) * 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. @@ -1791,16 +1762,15 @@ Tcl_GetChannelHandle(chan, direction, handlePtr) * * 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. @@ -1832,11 +1802,10 @@ AllocChannelBuffer(length) * * 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. @@ -1851,8 +1820,8 @@ static void 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. */ + int mustDiscard; /* If nonzero, free the buffer to the OS, + * always. */ { /* * Do we have to free the buffer to the OS? @@ -1864,9 +1833,9 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) } /* - * 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) { @@ -1882,11 +1851,11 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) if (statePtr->inQueueHead == (ChannelBuffer *) NULL) { statePtr->inQueueHead = bufPtr; statePtr->inQueueTail = bufPtr; - goto keepit; + goto keepBuffer; } if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) { statePtr->saveInBufPtr = bufPtr; - goto keepit; + goto keepBuffer; } } @@ -1897,7 +1866,7 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) if (statePtr->flags & TCL_WRITABLE) { if (statePtr->curOutPtr == (ChannelBuffer *) NULL) { statePtr->curOutPtr = bufPtr; - goto keepit; + goto keepBuffer; } } @@ -1908,7 +1877,7 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard) ckfree((char *) bufPtr); return; - keepit: + keepBuffer: bufPtr->nextRemoved = BUFFER_PADDING; bufPtr->nextAdded = BUFFER_PADDING; bufPtr->nextPtr = (ChannelBuffer *) NULL; @@ -1950,8 +1919,8 @@ DiscardOutputQueued(statePtr) * * 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 @@ -1972,7 +1941,7 @@ CheckForDeadChannel(interp, statePtr) if (interp) { Tcl_AppendResult(interp, "unable to access channel: invalid channel", - (char *) NULL); + (char *) NULL); } return 1; } @@ -1989,13 +1958,13 @@ CheckForDeadChannel(interp, statePtr) * event handler to flush channel output asynchronously. * * Results: - * 0 if successful, else the error code that was returned by the - * channel type operation. + * 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. * *---------------------------------------------------------------------- */ @@ -2004,9 +1973,9 @@ static int 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. */ + int calledFromAsyncFlush; /* If nonzero then we are being called + * from an asynchronous flush + * callback. */ { ChannelState *statePtr = chanPtr->state; /* State of the channel stack. */ @@ -2018,14 +1987,14 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) * 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. */ + 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)) { @@ -2033,12 +2002,11 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) } /* - * 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. */ 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 @@ -2062,8 +2030,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) bufPtr = statePtr->outQueueHead; /* - * If we are not being called from an async flush and an async - * flush is active, we just return without producing any output. + * If we are not being called from an async flush and an async flush + * is active, we just return without producing any output. */ if ((!calledFromAsyncFlush) && @@ -2106,16 +2074,16 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) } /* - * 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)) { /* - * 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 (!(statePtr->flags & BG_FLUSH_SCHEDULED)) { @@ -2140,8 +2108,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) /* * Casting away CONST here is safe because the - * TCL_VOLATILE flag guarantees CONST treatment - * of the Posix error string. + * TCL_VOLATILE flag guarantees CONST treatment of the + * Posix error string. */ Tcl_SetResult(interp, @@ -2150,8 +2118,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) } /* - * 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); @@ -2177,9 +2145,9 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) /* * 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 (statePtr->flags & BG_FLUSH_SCHEDULED) { @@ -2193,9 +2161,9 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) } /* - * 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 ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) && @@ -2219,15 +2187,15 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush) * elements of the NEXT channel into the TOP channel, in essence * unstacking the channel. The NEXT channel will then be freed. * - * If the channel was not stacked, then we will free all the bits - * for the TOP channel, including the data structure itself. + * If the channel was not stacked, then we will free all the bits for the + * TOP channel, including the data structure itself. * * Results: * 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. * *---------------------------------------------------------------------- */ @@ -2264,8 +2232,7 @@ CloseChannel(interp, chanPtr, errorCode) } /* - * 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 != (ChannelBuffer *) NULL) { @@ -2273,8 +2240,8 @@ CloseChannel(interp, chanPtr, errorCode) } /* - * 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) && (statePtr->flags & TCL_WRITABLE)) { @@ -2302,9 +2269,8 @@ CloseChannel(interp, chanPtr, errorCode) } /* - * 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) { @@ -2321,8 +2287,8 @@ CloseChannel(interp, chanPtr, errorCode) } /* - * 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) { @@ -2360,11 +2326,10 @@ CloseChannel(interp, chanPtr, errorCode) } /* - * 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 + * 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; @@ -2380,9 +2345,8 @@ CloseChannel(interp, chanPtr, errorCode) * * Tcl_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. @@ -2391,12 +2355,11 @@ CloseChannel(interp, chanPtr, errorCode) * 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. * *---------------------------------------------------------------------- */ @@ -2416,8 +2379,8 @@ Tcl_CutChannel(chan) 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)) { @@ -2437,10 +2400,10 @@ Tcl_CutChannel(chan) statePtr->nextCSPtr = (ChannelState *) NULL; /* TIP #218, Channel Thread Actions */ - threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan)); + threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan)); if (threadActionProc != NULL) { - (*threadActionProc) (Tcl_GetChannelInstanceData(chan), - TCL_CHANNEL_THREAD_REMOVE); + (*threadActionProc) (Tcl_GetChannelInstanceData(chan), + TCL_CHANNEL_THREAD_REMOVE); } } @@ -2449,9 +2412,9 @@ Tcl_CutChannel(chan) * * Tcl_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. @@ -2461,19 +2424,18 @@ Tcl_CutChannel(chan) * * 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. * *---------------------------------------------------------------------- */ void Tcl_SpliceChannel(chan) - Tcl_Channel chan; /* The channel being added. Must - * not be referenced in any + Tcl_Channel chan; /* The channel being added. Must not + * be referenced in any * interpreter. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); @@ -2488,18 +2450,18 @@ Tcl_SpliceChannel(chan) 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(); /* TIP #218, Channel Thread Actions */ - threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan)); + threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan)); if (threadActionProc != NULL) { - (*threadActionProc) (Tcl_GetChannelInstanceData(chan), - TCL_CHANNEL_THREAD_INSERT); + (*threadActionProc) (Tcl_GetChannelInstanceData(chan), + TCL_CHANNEL_THREAD_INSERT); } } @@ -2518,9 +2480,9 @@ Tcl_SpliceChannel(chan) * * 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. * *---------------------------------------------------------------------- */ @@ -2529,12 +2491,12 @@ Tcl_SpliceChannel(chan) int Tcl_Close(interp, chan) Tcl_Interp *interp; /* Interpreter for errors. */ - Tcl_Channel chan; /* The channel being closed. Must - * not be referenced in any + Tcl_Channel chan; /* The channel being closed. Must not + * be referenced in any * interpreter. */ { - CloseCallback *cbPtr; /* Iterate over close callbacks - * for this channel. */ + 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. */ @@ -2576,6 +2538,7 @@ Tcl_Close(interp, chan) * 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; @@ -2607,8 +2570,8 @@ Tcl_Close(interp, chan) } /* - * 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) { @@ -2619,9 +2582,9 @@ Tcl_Close(interp, chan) } /* - * 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. + * 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. */ statePtr->flags |= CHANNEL_CLOSED; @@ -2669,8 +2632,8 @@ Tcl_ClearChannelHandlers(channel) chanPtr = statePtr->topChanPtr; /* - * 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; @@ -2683,8 +2646,7 @@ Tcl_ClearChannelHandlers(channel) } /* - * 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; @@ -2702,10 +2664,10 @@ Tcl_ClearChannelHandlers(channel) StopCopy(statePtr->csPtr); /* - * Must set the interest mask now to 0, otherwise infinite loops - * will occur if Tcl_DoOneEvent is called before the channel is - * finally deleted in FlushChannel. This can happen if the channel - * has a background flush active. + * Must set the interest mask now to 0, otherwise infinite loops will + * occur if Tcl_DoOneEvent is called before the channel is finally deleted + * in FlushChannel. This can happen if the channel has a background flush + * active. */ statePtr->interestMask = 0; @@ -2729,11 +2691,11 @@ Tcl_ClearChannelHandlers(channel) * * 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. * @@ -2780,11 +2742,11 @@ Tcl_Write(chan, src, srcLen) * * Tcl_WriteRaw -- * - * Puts a sequence of bytes into an output buffer, may queue the - * buffer for output if it gets full, and also remembers whether the - * current buffer is ready e.g. if it contains a newline and we are in - * line buffering mode. 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. * @@ -2839,11 +2801,11 @@ Tcl_WriteRaw(chan, src, srcLen) * 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, @@ -2859,8 +2821,9 @@ Tcl_WriteRaw(chan, src, srcLen) int 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 + 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 */ @@ -2880,11 +2843,11 @@ Tcl_WriteChars(chan, src, len) * 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, @@ -2900,8 +2863,9 @@ Tcl_WriteChars(chan, src, len) static int 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 + CONST char *src; /* UTF-8 characters to queue in output + * buffer. */ + int len; /* Length of string in bytes, or < 0 for * strlen(). */ { /* @@ -2918,8 +2882,8 @@ DoWriteChars(chanPtr, src, len) } if (statePtr->encoding == NULL) { /* - * Inefficient way to convert UTF-8 to byte-array, but the - * code parallels the way it is done for objects. + * Inefficient way to convert UTF-8 to byte-array, but the code + * parallels the way it is done for objects. */ Tcl_Obj *objPtr; @@ -2939,17 +2903,17 @@ DoWriteChars(chanPtr, src, len) * * 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: @@ -2967,6 +2931,7 @@ Tcl_WriteObj(chan, objPtr) /* * Always use the topmost channel of the stack */ + Channel *chanPtr; ChannelState *statePtr; /* state info for channel */ char *src; @@ -2992,10 +2957,10 @@ Tcl_WriteObj(chan, objPtr) * * 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, @@ -3024,8 +2989,8 @@ WriteBytes(chanPtr, src, srcLen) savedLF = 0; /* - * 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) { @@ -3045,8 +3010,8 @@ WriteBytes(chanPtr, src, srcLen) 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 + * 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. */ @@ -3081,11 +3046,10 @@ WriteBytes(chanPtr, src, srcLen) * * 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, @@ -3144,10 +3108,10 @@ WriteChars(chanPtr, src, srcLen) 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). + * 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'; @@ -3185,9 +3149,8 @@ WriteChars(chanPtr, src, srcLen) 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((VOID *) dst, (VOID *) safe, (size_t) saved); @@ -3240,11 +3203,10 @@ WriteChars(chanPtr, src, srcLen) 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 = bufPtr->nextAdded - bufPtr->bufLength; @@ -3274,8 +3236,9 @@ WriteChars(chanPtr, src, srcLen) } } - /* 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)) { @@ -3290,37 +3253,36 @@ WriteChars(chanPtr, src, srcLen) * * 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. * *--------------------------------------------------------------------------- */ @@ -3336,9 +3298,9 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) 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; @@ -3347,68 +3309,64 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) srcLen = *srcLenPtr; switch (statePtr->outputTranslation) { - case TCL_TRANSLATE_LF: { - for (dstEnd = dst + srcLen; dst < dstEnd; ) { - if (*src == '\n') { - newlineFound = 1; - } - *dst++ = *src++; + case TCL_TRANSLATE_LF: + for (dstEnd = dst + srcLen; dst < dstEnd; ) { + if (*src == '\n') { + newlineFound = 1; } - *dstLenPtr = srcLen; - break; - } - case TCL_TRANSLATE_CR: { - for (dstEnd = dst + srcLen; dst < dstEnd;) { - if (*src == '\n') { - *dst++ = '\r'; - newlineFound = 1; - src++; - } else { - *dst++ = *src++; - } + *dst++ = *src++; + } + *dstLenPtr = srcLen; + break; + 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. - */ + *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; + char *dstStart, *dstMax; + CONST char *srcStart; - dstStart = dst; - dstMax = dst + *dstLenPtr; + dstStart = dst; + dstMax = dst + *dstLenPtr; - srcStart = src; + 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; + if (srcLen < *dstLenPtr) { + dstEnd = dst + srcLen; + } else { + dstEnd = dst + *dstLenPtr; + } + while (dst < dstEnd) { + if (*src == '\n') { + if (dstEnd < dstMax) { + dstEnd++; } - *dst++ = *src++; + *dst++ = '\r'; + newlineFound = 1; } - *srcLenPtr = src - srcStart; - *dstLenPtr = dst - dstStart; - break; - } - default: { - break; + *dst++ = *src++; } + *srcLenPtr = src - srcStart; + *dstLenPtr = dst - dstStart; + break; + } + default: + break; } return newlineFound; } @@ -3418,12 +3376,12 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr) * * 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. @@ -3435,8 +3393,8 @@ static int 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. */ + int newlineFlag; /* Non-zero if a the channel buffer contains a + * newline. */ { ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* @@ -3478,8 +3436,8 @@ CheckFlush(chanPtr, bufPtr, newlineFlag) * 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. * *--------------------------------------------------------------------------- */ @@ -3512,21 +3470,19 @@ Tcl_Gets(chan, lineRead) * 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. * *--------------------------------------------------------------------------- */ @@ -3561,8 +3517,8 @@ Tcl_GetsObj(chan, objPtr) 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. */ Tcl_GetStringFromObj(objPtr, &oldLength); @@ -3575,7 +3531,7 @@ Tcl_GetsObj(chan, objPtr) /* * If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't - * produce ByteArray objects. + * produce ByteArray objects. */ if (encoding == NULL) { @@ -3583,8 +3539,8 @@ Tcl_GetsObj(chan, objPtr) } /* - * 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; @@ -3613,8 +3569,8 @@ Tcl_GetsObj(chan, objPtr) } /* - * 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') { @@ -3633,115 +3589,109 @@ Tcl_GetsObj(chan, objPtr) */ 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; } - case TCL_TRANSLATE_CR: { - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\r') { - skip = 1; - goto goteol; - } + break; + case TCL_TRANSLATE_CR: + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + skip = 1; + goto gotEOL; } - break; } - case TCL_TRANSLATE_CRLF: { - for (eol = dst; eol < dstEnd; eol++) { - if (*eol == '\r') { - eol++; + 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. - */ + /* + * If a CR is at the end of the buffer, then check for a + * LF at the begining of the next buffer. + */ - if (eol >= dstEnd) { - int offset; - - offset = eol - objPtr->bytes; - dst = dstEnd; - if (FilterInputBytes(chanPtr, &gs) != 0) { - goto restore; - } - dstEnd = dst + gs.bytesWrote; - eol = objPtr->bytes + offset; - if (eol >= dstEnd) { - skip = 0; - goto goteol; - } + if (eol >= dstEnd) { + int offset; + + offset = eol - objPtr->bytes; + dst = dstEnd; + if (FilterInputBytes(chanPtr, &gs) != 0) { + goto restore; } - if (*eol == '\n') { - eol--; - skip = 2; - goto goteol; + dstEnd = dst + gs.bytesWrote; + eol = objPtr->bytes + offset; + if (eol >= dstEnd) { + skip = 0; + goto gotEOL; } } + if (*eol == '\n') { + eol--; + skip = 2; + goto gotEOL; + } + } + } + break; + case TCL_TRANSLATE_AUTO: + eol = dst; + skip = 1; + if (statePtr->flags & INPUT_SAW_CR) { + statePtr->flags &= ~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, + 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--; } - break; } - case TCL_TRANSLATE_AUTO: { - eol = dst; - skip = 1; - if (statePtr->flags & INPUT_SAW_CR) { - statePtr->flags &= ~INPUT_SAW_CR; - if ((eol < dstEnd) && (*eol == '\n')) { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + eol++; + if (eol == dstEnd) { /* - * Skip the raw bytes that make up the '\n'. + * If buffer ended on \r, peek ahead to see if a \n is + * available. */ - 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 == '\n') { - skip++; + 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; } - eol--; - goto goteol; - } else if (*eol == '\n') { - goto goteol; } + if (*eol == '\n') { + skip++; + } + eol--; + goto gotEOL; + } else if (*eol == '\n') { + goto gotEOL; } } } @@ -3770,20 +3720,20 @@ Tcl_GetsObj(chan, objPtr) 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. + * 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: + gotEOL: bufPtr = gs.bufPtr; statePtr->inputEncodingState = gs.state; Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved, @@ -3805,11 +3755,11 @@ Tcl_GetsObj(chan, objPtr) /* * 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. + * reading from the channel or we are non-blocking and there wasn't an EOL + * or EOF in the data available. */ - restore: + restore: bufPtr = statePtr->inQueueHead; bufPtr->nextRemoved = oldRemoved; @@ -3824,11 +3774,11 @@ Tcl_GetsObj(chan, objPtr) /* * 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 + * 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. */ @@ -3836,12 +3786,12 @@ Tcl_GetsObj(chan, objPtr) 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: UpdateInterest(chanPtr); return copiedTotal; } @@ -3851,21 +3801,21 @@ Tcl_GetsObj(chan, objPtr) * * 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. * *--------------------------------------------------------------------------- */ @@ -3881,9 +3831,9 @@ FilterInputBytes(chanPtr, gsPtr) 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. */ @@ -3906,12 +3856,12 @@ FilterInputBytes(chanPtr, gsPtr) 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: + read: if (statePtr->flags & CHANNEL_BLOCKED) { if (statePtr->flags & CHANNEL_NONBLOCKING) { gsPtr->charsWrote = 0; @@ -3975,8 +3925,8 @@ FilterInputBytes(chanPtr, gsPtr) 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; @@ -3999,8 +3949,8 @@ FilterInputBytes(chanPtr, gsPtr) 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; @@ -4028,9 +3978,9 @@ FilterInputBytes(chanPtr, gsPtr) * * 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 @@ -4048,8 +3998,8 @@ FilterInputBytes(chanPtr, gsPtr) static void PeekAhead(chanPtr, dstEndPtr, gsPtr) Channel *chanPtr; /* The channel to read. */ - char **dstEndPtr; /* Filled with pointer to end of new range - * of UTF-8 characters. */ + 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 */ @@ -4061,10 +4011,10 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr) /* * 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; @@ -4099,7 +4049,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr) } return; - cleanup: + cleanup: bufPtr->nextRemoved += gsPtr->rawRead; gsPtr->rawRead = 0; gsPtr->totalChars += gsPtr->charsWrote; @@ -4112,8 +4062,8 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr) * * 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. @@ -4178,16 +4128,16 @@ CommonGetsCleanup(chanPtr, encoding) * * 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 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. @@ -4201,7 +4151,7 @@ Tcl_Read(chan, dst, bytesToRead) char *dst; /* Where to store input read. */ int bytesToRead; /* Maximum number of bytes to read. */ { - Channel *chanPtr = (Channel *) chan; + Channel *chanPtr = (Channel *) chan; ChannelState *statePtr = chanPtr->state; /* state info for channel */ /* @@ -4222,16 +4172,16 @@ Tcl_Read(chan, dst, bytesToRead) * * Tcl_ReadRaw -- * - * Reads a given number of bytes from a channel. EOL and EOF - * translation is done on the bytes being read, so the 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 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. @@ -4245,7 +4195,7 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) char *bufPtr; /* Where to store input read. */ int bytesToRead; /* Maximum number of bytes to read. */ { - Channel *chanPtr = (Channel *) chan; + Channel *chanPtr = (Channel *) chan; ChannelState *statePtr = chanPtr->state; /* state info for channel */ int nread, result; int copied, copiedNow; @@ -4253,9 +4203,9 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) /* * 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 @@ -4267,9 +4217,9 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) } /* - * 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) { @@ -4287,28 +4237,30 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) } #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - /* [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. + /* + * [SF Tcl Bug 943274]. Better emulation of non-blocking channels + * for channels without BlockModeProc, by keeping track of true + * fileevents generated by the OS == Data waiting and reading if + * and only if we are sure to have data. */ if ((statePtr->flags & CHANNEL_NONBLOCKING) && (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) && !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) { /* - * We bypass the driver, it would block, as no data is - * available + * 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 + * 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. @@ -4316,9 +4268,11 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) 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 @@ -4335,16 +4289,18 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING if (nread <= (bytesToRead - copied)) { /* - * [SF Tcl Bug 943274] We have read the available - * data, clear flag. + * [SF Tcl Bug 943274] We have read the available data, + * clear flag. */ statePtr->flags &= ~CHANNEL_HAS_MORE_DATA; } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ + } else if (nread == 0) { statePtr->flags |= CHANNEL_EOF; statePtr->inputEncodingFlags |= TCL_ENCODING_END; + } else if (nread < 0) { if ((result == EWOULDBLOCK) || (result == EAGAIN)) { if (copied > 0) { @@ -4362,13 +4318,13 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead) Tcl_SetErrno(result); return -1; - } + } return copied + nread; } } -done: + done: return copied; } @@ -4377,16 +4333,16 @@ done: * * 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. @@ -4398,9 +4354,9 @@ int 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 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 @@ -4432,16 +4388,16 @@ Tcl_ReadChars(chan, 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. @@ -4453,9 +4409,9 @@ static int 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 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 @@ -4480,10 +4436,11 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) 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). */ Tcl_GetString(objPtr); @@ -4523,6 +4480,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) } } } + if (copiedNow < 0) { if (statePtr->flags & CHANNEL_EOF) { break; @@ -4546,6 +4504,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) toRead -= copiedNow; } } + statePtr->flags &= ~CHANNEL_BLOCKED; if (encoding == NULL) { Tcl_SetByteArrayLength(objPtr, offset); @@ -4553,12 +4512,12 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) 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: UpdateInterest(chanPtr); return copied; } @@ -4567,20 +4526,19 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag) * * 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. @@ -4592,22 +4550,21 @@ static int 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. 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; @@ -4615,7 +4572,7 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr) offset = *offsetPtr; - bufPtr = statePtr->inQueueHead; + bufPtr = statePtr->inQueueHead; src = bufPtr->buf + bufPtr->nextRemoved; srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; @@ -4627,9 +4584,9 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr) 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; @@ -4670,21 +4627,19 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr) * * 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. + * 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. + * '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. @@ -4699,18 +4654,18 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) * 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 *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 @@ -4726,7 +4681,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) factor = *factorPtr; offset = *offsetPtr; - bufPtr = statePtr->inQueueHead; + bufPtr = statePtr->inQueueHead; src = bufPtr->buf + bufPtr->nextRemoved; srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; @@ -4736,10 +4691,9 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) } /* - * '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 = toRead * factor / UTF_EXPANSION_FACTOR; @@ -4747,9 +4701,9 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) 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. */ length = offset * 2; @@ -4762,9 +4716,9 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) } 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; @@ -4804,9 +4758,9 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); 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; @@ -4821,11 +4775,10 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) * * 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. + * 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. */ statePtr->flags |= CHANNEL_NEED_MORE_DATA; @@ -4843,10 +4796,10 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) 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) { @@ -4857,12 +4810,12 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) 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); @@ -4898,12 +4851,12 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) * * 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. @@ -4913,19 +4866,19 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr) static int 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. */ + 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 + * 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; @@ -4936,10 +4889,10 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) 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; @@ -4958,101 +4911,99 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) } } switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: { - if (dstStart != srcStart) { - memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); - } - srcLen = dstLen; - break; - } - case TCL_TRANSLATE_CR: { - char *dst, *dstEnd; - - if (dstStart != srcStart) { - memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); + case TCL_TRANSLATE_LF: + if (dstStart != srcStart) { + memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); + } + srcLen = dstLen; + break; + 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'; } - 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; + srcLen = dstLen; + break; + } + case TCL_TRANSLATE_CRLF: { + 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; - 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 { + 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++ = *src++; } - srcLen = src - srcStart; - dstLen = dst - dstStart; - break; } - case TCL_TRANSLATE_AUTO: { - char *dst; - CONST char *src, *srcEnd, *srcMax; + srcLen = src - srcStart; + dstLen = dst - dstStart; + break; + } + 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 ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) { - if (*src == '\n') { - src++; - } - statePtr->flags &= ~INPUT_SAW_CR; + if ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) { + if (*src == '\n') { + src++; } - for ( ; src < srcEnd; ) { - if (*src == '\r') { - src++; - if (src >= srcMax) { - statePtr->flags |= INPUT_SAW_CR; - } else if (*src == '\n') { - if (srcEnd < srcMax) { - srcEnd++; - } - src++; + statePtr->flags &= ~INPUT_SAW_CR; + } + for ( ; src < srcEnd; ) { + if (*src == '\r') { + src++; + if (src >= srcMax) { + statePtr->flags |= INPUT_SAW_CR; + } else if (*src == '\n') { + if (srcEnd < srcMax) { + srcEnd++; } - *dst++ = '\n'; - } else { - *dst++ = *src++; + 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. */ statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); @@ -5070,8 +5021,8 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr) * * 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. @@ -5088,7 +5039,7 @@ Tcl_Ungets(chan, str, len, atEnd) CONST char *str; /* The input itself. */ int len; /* The length of the input. */ int atEnd; /* If non-zero, add at end of queue; otherwise - * add at head of queue. */ + * add at head of queue. */ { Channel *chanPtr; /* The real IO channel. */ ChannelState *statePtr; /* State of actual channel. */ @@ -5116,11 +5067,10 @@ Tcl_Ungets(chan, str, len, atEnd) 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 (statePtr->flags & CHANNEL_STICKY_EOF) { @@ -5146,12 +5096,12 @@ Tcl_Ungets(chan, str, len, atEnd) 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; } @@ -5213,8 +5163,8 @@ Tcl_Flush(chan) * * 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. @@ -5228,8 +5178,8 @@ Tcl_Flush(chan) static void DiscardInputQueued(statePtr, discardSavedBuffers) - ChannelState *statePtr; /* Channel on which to discard - * the queued input. */ + ChannelState *statePtr; /* Channel on which to discard the queued + * input. */ int discardSavedBuffers; /* If non-zero, discard all buffers including * last one. */ { @@ -5261,11 +5211,11 @@ DiscardInputQueued(statePtr, discardSavedBuffers) * * 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. @@ -5295,13 +5245,13 @@ GetInput(chanPtr) } /* - * 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 != (ChannelBuffer *) NULL) { @@ -5318,14 +5268,14 @@ GetInput(chanPtr) } /* - * 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; @@ -5338,8 +5288,8 @@ GetInput(chanPtr) /* * 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. + * squashed. This is done to honor dynamic changes of the buffersize + * made by the user. */ if ((bufPtr != NULL) @@ -5353,17 +5303,18 @@ GetInput(chanPtr) } 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 = bufPtr->bufLength - bufPtr->nextAdded; @@ -5387,10 +5338,10 @@ GetInput(chanPtr) #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING /* - * [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. + * [SF Tcl Bug 943274]. Better emulation of non-blocking channels for + * channels without BlockModeProc, by keeping track of true fileevents + * generated by the OS == Data waiting and reading if and only if we are + * sure to have data. */ if ((statePtr->flags & CHANNEL_NONBLOCKING) && @@ -5404,8 +5355,10 @@ GetInput(chanPtr) result = EWOULDBLOCK; } else { #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ + nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData, bufPtr->buf + bufPtr->nextAdded, toRead, &result); + #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING } #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ @@ -5414,10 +5367,10 @@ GetInput(chanPtr) 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) { @@ -5427,8 +5380,8 @@ GetInput(chanPtr) #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING if (nread <= toRead) { /* - * [SF Tcl Bug 943274] We have read the available data, - * clear flag. + * [SF Tcl Bug 943274] We have read the available data, clear + * flag. */ statePtr->flags &= ~CHANNEL_HAS_MORE_DATA; @@ -5454,12 +5407,12 @@ GetInput(chanPtr) * * 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. @@ -5479,19 +5432,19 @@ Tcl_Seek(chan, offset, mode) /* # 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 - * nonblocking mode after the seek. */ + int wasAsync; /* Was the channel nonblocking before the seek + * operation? If so, must restore to + * non-blocking 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)) { @@ -5515,8 +5468,8 @@ Tcl_Seek(chan, offset, mode) } /* - * 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); @@ -5537,25 +5490,25 @@ Tcl_Seek(chan, offset, mode) } /* - * 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. */ 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; @@ -5572,8 +5525,8 @@ Tcl_Seek(chan, offset, mode) } /* - * If there is data buffered in statePtr->curOutPtr then mark - * the channel as ready to flush before invoking FlushChannel. + * If there is data buffered in statePtr->curOutPtr then mark the channel + * as ready to flush before invoking FlushChannel. */ if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) && @@ -5583,11 +5536,11 @@ Tcl_Seek(chan, offset, mode) } /* - * 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) { @@ -5596,8 +5549,8 @@ Tcl_Seek(chan, offset, mode) /* * 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... + * caller. Note that we prefer the wideSeekProc if that is available + * and non-NULL... */ if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && @@ -5621,8 +5574,8 @@ Tcl_Seek(chan, offset, mode) /* * 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) { @@ -5641,13 +5594,13 @@ Tcl_Seek(chan, offset, mode) * * 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. @@ -5672,8 +5625,8 @@ Tcl_Tell(chan) /* * 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)) { @@ -5697,8 +5650,8 @@ Tcl_Tell(chan) } /* - * 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); @@ -5710,9 +5663,9 @@ Tcl_Tell(chan) } /* - * 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... */ if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && @@ -5738,9 +5691,9 @@ Tcl_Tell(chan) * * 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 @@ -5783,13 +5736,12 @@ Tcl_TellOld(chan) * 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). + * 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. + * Seeks the channel to the current location. Sets errno on OS error. * *--------------------------------------------------------------------------- */ @@ -5815,17 +5767,16 @@ Tcl_TruncateChannel(chan, length) if (!(chanPtr->state->flags & 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. + * 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. + * Seek first to force a total flush of all pending buffers and ditch any + * pre-read input data. */ if (Tcl_Seek(chan, 0, SEEK_CUR) == Tcl_LongAsWide(-1)) { @@ -5833,9 +5784,8 @@ Tcl_TruncateChannel(chan, length) } /* - * We're all flushed to disk now and we also don't have any - * unfortunate input baggage around either; can truncate with - * impunity. + * 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); @@ -5851,12 +5801,12 @@ Tcl_TruncateChannel(chan, length) * * 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. @@ -5885,8 +5835,8 @@ CheckChannelErrors(statePtr, flags) } /* - * 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 ((statePtr->flags & CHANNEL_CLOSED) && @@ -5919,10 +5869,10 @@ CheckChannelErrors(statePtr, flags) 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 ((statePtr->flags & CHANNEL_STICKY_EOF) == 0) { @@ -5993,12 +5943,12 @@ Tcl_InputBlocked(chan) * * 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. @@ -6039,12 +5989,12 @@ Tcl_InputBuffered(chan) * * 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. @@ -6084,8 +6034,8 @@ Tcl_OutputBuffered(chan) * 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. @@ -6116,8 +6066,8 @@ Tcl_ChannelBuffered(chan) * * 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. @@ -6130,15 +6080,15 @@ Tcl_ChannelBuffered(chan) void Tcl_SetChannelBufferSize(chan, sz) - Tcl_Channel chan; /* The channel whose buffer size - * to set. */ + Tcl_Channel chan; /* The channel whose buffer size to + * set. */ int sz; /* The size to set. */ { ChannelState *statePtr; /* State of real channel structure. */ /* - * If the buffer size is smaller than 1 byte or larger than one MByte, - * do not accept the requested size and leave the current buffer size. + * If the buffer size is smaller than 1 byte or larger than one MByte, do + * not accept the requested size and leave the current buffer size. */ if (sz < 1) { @@ -6157,7 +6107,7 @@ Tcl_SetChannelBufferSize(chan, sz) } if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { statePtr->outputStage = (char *) - ckalloc((unsigned) (statePtr->bufSize + 2)); + ckalloc((unsigned) (statePtr->bufSize + 2)); } } @@ -6193,43 +6143,44 @@ Tcl_GetChannelBufferSize(chan) * * 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 + + * 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. + * "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(interp, optionName, optionList) - Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/ + 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 + CONST char *optionList; /* Specific options list to append to + * the standard generic options. Can + * be NULL for generic options * only. */ { - if (interp) { - CONST char *genericopt = - "blocking buffering buffersize encoding eofchar translation"; + if (interp != NULL) { + CONST char *genericopt = + "blocking buffering buffersize encoding eofchar translation"; CONST char **argv; - int argc, i; + int argc, i; Tcl_DString ds; Tcl_DStringInit(&ds); @@ -6238,12 +6189,12 @@ Tcl_BadChannelOption(interp, optionName, optionList) 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"); } Tcl_ResetResult(interp); - Tcl_AppendResult(interp, "bad option \"", optionName, + Tcl_AppendResult(interp, "bad option \"", optionName, "\": should be one of ", (char *) NULL); argc--; for (i = 0; i < argc; i++) { @@ -6262,14 +6213,14 @@ Tcl_BadChannelOption(interp, optionName, optionList) * * 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. @@ -6293,8 +6244,8 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) /* * 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)) { @@ -6322,8 +6273,8 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) } /* - * 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 == (char *) NULL) { @@ -6477,15 +6428,15 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) } 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); } else { /* - * no driver specific options case. + * No driver specific options case. */ if (len == 0) { @@ -6503,8 +6454,8 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr) * 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. @@ -6540,8 +6491,8 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) /* * 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)) { @@ -6665,9 +6616,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) } /* - * [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. + * [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. */ statePtr->flags &= @@ -6707,7 +6658,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) } 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; @@ -6729,9 +6680,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) } /* - * 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) { @@ -6746,10 +6697,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) /* 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) { @@ -6760,7 +6710,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) } 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; @@ -6781,7 +6731,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) return TCL_ERROR; } } - ckfree((char *) argv); + ckfree((char *) argv); return TCL_OK; } else if (chanPtr->typePtr->setOptionProc != NULL) { return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData, @@ -6817,7 +6767,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) statePtr->outputStage = NULL; } if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) { - statePtr->outputStage = (char *) + statePtr->outputStage = (char *) ckalloc((unsigned) (statePtr->bufSize + 2)); } return TCL_OK; @@ -6828,11 +6778,10 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue) * * 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. @@ -6852,8 +6801,8 @@ CleanupChannelHandlers(interp, chanPtr) EventScriptRecord *sPtr, *prevPtr, *nextPtr; /* - * Remove fileevent records on this channel that refer to the - * given interpreter. + * Remove fileevent records on this channel that refer to the given + * interpreter. */ for (sPtr = statePtr->scriptRecordPtr, @@ -6884,10 +6833,9 @@ CleanupChannelHandlers(interp, chanPtr) * * Tcl_NotifyChannel -- * - * This procedure is called by a channel driver when a driver - * detects an event on a channel. This procedure is responsible - * 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. @@ -6914,10 +6862,10 @@ Tcl_NotifyChannel(channel, mask) 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) && @@ -6930,15 +6878,15 @@ Tcl_NotifyChannel(channel, mask) #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 != ((Channel *) NULL))) { @@ -6951,10 +6899,10 @@ Tcl_NotifyChannel(channel, 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; @@ -6963,8 +6911,8 @@ Tcl_NotifyChannel(channel, mask) 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) { @@ -6972,8 +6920,8 @@ Tcl_NotifyChannel(channel, mask) } /* - * 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. */ @@ -6982,10 +6930,9 @@ Tcl_NotifyChannel(channel, mask) 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 ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) { @@ -7018,9 +6965,9 @@ Tcl_NotifyChannel(channel, mask) } /* - * 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) { @@ -7038,8 +6985,8 @@ Tcl_NotifyChannel(channel, mask) * * 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. @@ -7058,8 +7005,8 @@ UpdateInterest(chanPtr) 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 (statePtr->flags & BG_FLUSH_SCHEDULED) { @@ -7083,41 +7030,39 @@ UpdateInterest(chanPtr) /* * 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 + * 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; @@ -7136,8 +7081,8 @@ UpdateInterest(chanPtr) * * 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. @@ -7161,19 +7106,20 @@ ChannelTimerProc(clientData) && (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, (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 ((statePtr->flags & CHANNEL_NONBLOCKING) && @@ -7186,7 +7132,7 @@ ChannelTimerProc(clientData) Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - statePtr->flags &= ~CHANNEL_TIMER_FEV; + statePtr->flags &= ~CHANNEL_TIMER_FEV; #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ Tcl_Release((ClientData) statePtr); @@ -7201,19 +7147,18 @@ ChannelTimerProc(clientData) * * 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. * *---------------------------------------------------------------------- */ @@ -7222,12 +7167,12 @@ void 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. */ + * 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; @@ -7235,9 +7180,9 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData) 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; @@ -7259,16 +7204,15 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData) } /* - * 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; @@ -7286,15 +7230,14 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData) * * 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. * *---------------------------------------------------------------------- @@ -7305,8 +7248,8 @@ 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. */ + ClientData clientData; /* The client data in the callback to + * delete. */ { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ChannelHandler *chPtr, *prevChPtr; @@ -7362,8 +7305,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData) /* * 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; @@ -7381,8 +7323,8 @@ Tcl_DeleteChannelHandler(chan, proc, clientData) * * 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. @@ -7397,10 +7339,10 @@ static void 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. */ + 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; @@ -7446,12 +7388,12 @@ DeleteScriptRecord(interp, chanPtr, mask) static void 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_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 */ @@ -7486,9 +7428,9 @@ CreateScriptRecord(interp, chanPtr, mask, scriptPtr) * * 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. @@ -7517,17 +7459,17 @@ TclChannelEventScriptInvoker(clientData, 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((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. @@ -7547,10 +7489,10 @@ TclChannelEventScriptInvoker(clientData, mask) * * 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. @@ -7566,13 +7508,13 @@ int Tcl_FileEventObjCmd(clientData, interp, objc, objv) ClientData clientData; /* Not used. */ Tcl_Interp *interp; /* Interpreter in which the channel - * for which to create the handler - * is found. */ + * for which to create the handler is + * found. */ int objc; /* Number of arguments. */ Tcl_Obj *CONST objv[]; /* Argument objects. */ { - Channel *chanPtr; /* The channel to create - * the handler for. */ + 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; @@ -7632,9 +7574,9 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv) } /* - * 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]); @@ -7648,17 +7590,17 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv) * 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. * *---------------------------------------------------------------------- */ @@ -7697,8 +7639,8 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) /* * 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. + * non-blocking channels. Foreground copies need blocking channels. If + * there is an error, restore the old blocking mode. */ if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) { @@ -7707,7 +7649,7 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) != TCL_OK) { return TCL_ERROR; } - } + } if (inPtr != outPtr) { if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) { if (SetBlockMode(NULL, outPtr, @@ -7764,8 +7706,8 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) * * 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. @@ -7789,7 +7731,7 @@ CopyData(csPtr, mask) char *buffer; int inBinary, outBinary, sameEncoding; /* Encoding control */ - int underflow; /* input underflow */ + int underflow; /* input underflow */ inChan = (Tcl_Channel) csPtr->readPtr; outChan = (Tcl_Channel) csPtr->writePtr; @@ -7801,9 +7743,9 @@ CopyData(csPtr, mask) /* * 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); @@ -7849,7 +7791,7 @@ CopyData(csPtr, mask) underflow = (size >= 0) && (size < sizeb); /* input underflow */ if (size < 0) { - readError: + readError: TclNewObj(errObj); Tcl_AppendStringsToObj(errObj, "error reading \"", Tcl_GetChannelName(inChan), "\": ", @@ -7857,9 +7799,9 @@ CopyData(csPtr, mask) break; } else if (underflow) { /* - * We had an underflow on the read side. If we are at EOF, - * 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, 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)) { @@ -7905,7 +7847,7 @@ CopyData(csPtr, mask) } /* else : Read counted characters, write counted bytes, i.e. size != sizeb */ if (sizeb < 0) { - writeError: + writeError: TclNewObj(errObj); Tcl_AppendStringsToObj(errObj, "error writing \"", Tcl_GetChannelName(outChan), "\": ", @@ -7914,10 +7856,10 @@ CopyData(csPtr, mask) } /* - * 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) { @@ -7957,14 +7899,14 @@ CopyData(csPtr, mask) } /* - * 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) { /* - * 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) { @@ -7985,16 +7927,16 @@ CopyData(csPtr, mask) } /* - * 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) { /* - * 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); @@ -8035,8 +7977,8 @@ CopyData(csPtr, mask) * 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. @@ -8051,16 +7993,16 @@ DoRead(chanPtr, bufPtr, toRead) 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 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 (!(statePtr->flags & CHANNEL_STICKY_EOF)) { @@ -8093,12 +8035,12 @@ DoRead(chanPtr, bufPtr, toRead) 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; } @@ -8108,13 +8050,13 @@ DoRead(chanPtr, bufPtr, toRead) * * 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. @@ -8126,22 +8068,22 @@ static int 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? */ + 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. */ + 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 == (ChannelBuffer *) NULL) { @@ -8152,165 +8094,157 @@ CopyAndTranslateBuffer(statePtr, result, space) copied = 0; switch (statePtr->inputTranslation) { - case TCL_TRANSLATE_LF: { - if (bytesInBuffer == 0) { - return 0; - } + case TCL_TRANSLATE_LF: + if (bytesInBuffer == 0) { + return 0; + } - /* - * Copy the current chunk into the result buffer. - */ + /* + * Copy the current chunk into the result buffer. + */ - if (bytesInBuffer < space) { - space = bytesInBuffer; - } - memcpy((VOID *) result, - (VOID *) (bufPtr->buf + bufPtr->nextRemoved), - (size_t) space); - bufPtr->nextRemoved += space; - copied = space; - break; + if (bytesInBuffer < space) { + space = bytesInBuffer; } - case TCL_TRANSLATE_CR: { - char *end; + memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved), + (size_t) space); + bufPtr->nextRemoved += space; + copied = space; + break; + case TCL_TRANSLATE_CR: { + char *end; - if (bytesInBuffer == 0) { - return 0; - } + if (bytesInBuffer == 0) { + return 0; + } - /* - * Copy the current chunk into the result buffer, then - * replace all \r with \n. - */ + /* + * Copy the current chunk into the result buffer, then replace all \r + * with \n. + */ - if (bytesInBuffer < space) { - space = bytesInBuffer; - } - 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'; - } + 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; + break; + } + case TCL_TRANSLATE_CRLF: { + char *src, *end, *dst; + int curByte; - /* - * If there is a held-back "\r" at EOF, produce it now. - */ + /* + * If there is a held-back "\r" at EOF, produce it now. + */ - if (bytesInBuffer == 0) { - if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) == - (INPUT_SAW_CR | CHANNEL_EOF)) { - result[0] = '\r'; - statePtr->flags &= ~INPUT_SAW_CR; - return 1; - } - return 0; + 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"!). - */ + /* + * 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; - if (bytesInBuffer < space) { - space = bytesInBuffer; + 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++; } - 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++; - } + if (curByte == '\r') { + statePtr->flags |= INPUT_SAW_CR; + } else { + *dst = (char) curByte; + dst++; } - copied = dst - result; - break; } - case TCL_TRANSLATE_AUTO: { - char *src, *end, *dst; - int curByte; + copied = dst - result; + break; + } + case TCL_TRANSLATE_AUTO: { + char *src, *end, *dst; + int curByte; - if (bytesInBuffer == 0) { - return 0; - } + if (bytesInBuffer == 0) { + return 0; + } - /* - * Loop over the current buffer, converting "\r" and "\r\n" - * to "\n". - */ + /* + * 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'; + 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++; - } else { - if ((curByte != '\n') || - !(statePtr->flags & INPUT_SAW_CR)) { - *dst = (char) curByte; - dst++; - } - statePtr->flags &= ~INPUT_SAW_CR; } + statePtr->flags &= ~INPUT_SAW_CR; } - copied = dst - result; - break; - } - default: { - Tcl_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) { /* - * 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. */ statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); @@ -8334,9 +8268,9 @@ CopyAndTranslateBuffer(statePtr, result, space) } /* - * 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; @@ -8350,8 +8284,8 @@ CopyAndTranslateBuffer(statePtr, result, space) * 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. @@ -8363,21 +8297,21 @@ static int CopyBuffer(chanPtr, result, space) Channel *chanPtr; /* Channel from which to read input. */ char *result; /* Where to store the copied input. */ - int space; /* How many bytes are available in result - * to store the copied input? */ + 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? */ /* - * 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 == (ChannelBuffer *) NULL) { @@ -8403,16 +8337,15 @@ CopyBuffer(chanPtr, result, space) space = bytesInBuffer; } - memcpy((VOID *) result, - (VOID *) (bufPtr->buf + bufPtr->nextRemoved), - (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. */ /* @@ -8468,16 +8401,16 @@ DoWrite(chanPtr, src, srcLen) 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. */ + * 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? */ + 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? */ /* @@ -8514,41 +8447,41 @@ DoWrite(chanPtr, src, 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'; - } + 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--; - } + } + 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 = *sPtr; + *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"); + } + break; + case TCL_TRANSLATE_AUTO: + Tcl_Panic("Tcl_Write: AUTO output translation mode not supported"); + default: + Tcl_Panic("Tcl_Write: unknown output translation mode"); } /* @@ -8597,9 +8530,9 @@ DoWrite(chanPtr, src, srcLen) * * CopyEventProc -- * - * This routine is invoked as a channel event handler for - * the background copy operation. It is just a trivial wrapper - * 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. @@ -8615,7 +8548,7 @@ CopyEventProc(clientData, mask) ClientData clientData; int mask; { - (void) CopyData((CopyState *)clientData, mask); + (void) CopyData((CopyState *) clientData, mask); } /* @@ -8629,8 +8562,8 @@ CopyEventProc(clientData, mask) * 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. * *---------------------------------------------------------------------- */ @@ -8667,14 +8600,14 @@ StopCopy(csPtr) } 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, - (ClientData)csPtr); + Tcl_DeleteChannelHandler((Tcl_Channel) csPtr->readPtr, CopyEventProc, + (ClientData) csPtr); if (csPtr->readPtr != csPtr->writePtr) { - Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr, - CopyEventProc, (ClientData)csPtr); + Tcl_DeleteChannelHandler((Tcl_Channel) csPtr->writePtr, + CopyEventProc, (ClientData) csPtr); } TclDecrRefCount(csPtr->cmdPtr); } @@ -8688,15 +8621,15 @@ StopCopy(csPtr) * * 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. * *---------------------------------------------------------------------- */ @@ -8734,15 +8667,15 @@ StackSetBlockMode(chanPtr, mode) * * 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. * *---------------------------------------------------------------------- */ @@ -8801,9 +8734,9 @@ Tcl_GetChannelNames(interp) * * 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. @@ -8832,8 +8765,8 @@ Tcl_GetChannelNamesEx(interp, pattern) } /* - * 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); @@ -8861,8 +8794,8 @@ Tcl_GetChannelNamesEx(interp, pattern) 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; @@ -8871,12 +8804,13 @@ Tcl_GetChannelNamesEx(interp, pattern) if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) && (Tcl_ListObjAppendElement(interp, resultPtr, Tcl_NewStringObj(name, -1)) != TCL_OK)) { -error: + error: TclDecrRefCount(resultPtr); return TCL_ERROR; } } -done: + + done: Tcl_SetObjResult(interp, resultPtr); return TCL_OK; } @@ -8886,8 +8820,8 @@ done: * * 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. @@ -8900,8 +8834,8 @@ done: int Tcl_IsChannelRegistered(interp, chan) - Tcl_Interp *interp; /* The interp to query of the channel */ - Tcl_Channel chan; /* The channel to check */ + 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. */ @@ -8909,8 +8843,8 @@ Tcl_IsChannelRegistered(interp, chan) 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; @@ -8963,8 +8897,8 @@ Tcl_IsChannelShared(chan) * 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). @@ -9058,8 +8992,8 @@ Tcl_ChannelVersion(chanTypePtr) return TCL_CHANNEL_VERSION_4; } 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; @@ -9416,8 +9350,8 @@ Tcl_ChannelWideSeekProc(chanTypePtr) * * Tcl_ChannelThreadActionProc -- * - * TIP #218, Channel Thread Actions. - * Return the Tcl_DriverThreadActionProc of the channel type. + * TIP #218, Channel Thread Actions. Return the + * Tcl_DriverThreadActionProc of the channel type. * * Results: * A pointer to the proc. @@ -9444,7 +9378,7 @@ Tcl_ChannelThreadActionProc(chanTypePtr) * * Tcl_ChannelTruncateProc -- * - * TIP #208 (subsection relating to truncation, based on TIP #206). + * TIP #208 (subsection relating to truncation, based on TIP #206). * Return the Tcl_DriverTruncateProc of the channel type. * * Results: @@ -9469,41 +9403,52 @@ Tcl_ChannelTruncateProc(chanTypePtr) #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(str, flags) - char *str; - int flags; + char *str; + int flags; { char buf[20]; int i = 0; - if (flags & TCL_READABLE) buf[i++] = 'r'; else buf[i++]='_'; - if (flags & TCL_WRITABLE) buf[i++] = 'w'; else buf[i++]='_'; - if (flags & CHANNEL_NONBLOCKING) buf[i++] = 'n'; else buf[i++]='_'; - if (flags & CHANNEL_LINEBUFFERED) buf[i++] = 'l'; else buf[i++]='_'; - if (flags & CHANNEL_UNBUFFERED) buf[i++] = 'u'; else buf[i++]='_'; - if (flags & BUFFER_READY) buf[i++] = 'R'; else buf[i++]='_'; - if (flags & BG_FLUSH_SCHEDULED) buf[i++] = 'F'; else buf[i++]='_'; - if (flags & CHANNEL_CLOSED) buf[i++] = 'c'; else buf[i++]='_'; - if (flags & CHANNEL_EOF) buf[i++] = 'E'; else buf[i++]='_'; - if (flags & CHANNEL_STICKY_EOF) buf[i++] = 'S'; else buf[i++]='_'; - if (flags & CHANNEL_BLOCKED) buf[i++] = 'B'; else buf[i++]='_'; - if (flags & INPUT_SAW_CR) buf[i++] = '/'; else buf[i++]='_'; - if (flags & INPUT_NEED_NL) buf[i++] = '*'; else buf[i++]='_'; - if (flags & CHANNEL_DEAD) buf[i++] = 'D'; else buf[i++]='_'; - if (flags & CHANNEL_RAW_MODE) buf[i++] = 'R'; else buf[i++]='_'; +#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); #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING - if (flags & CHANNEL_TIMER_FEV) buf[i++] = 'T'; else buf[i++]='_'; - if (flags & CHANNEL_HAS_MORE_DATA) buf[i++] = 'H'; else buf[i++]='_'; + ChanFlag('T', CHANNEL_TIMER_FEV); + ChanFlag('H', CHANNEL_HAS_MORE_DATA); #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */ - if (flags & CHANNEL_INCLOSE) buf[i++] = 'x'; else buf[i++]='_'; + ChanFlag('x', CHANNEL_INCLOSE); + buf[i] ='\0'; - fprintf(stderr,"%s: %s\n", str, buf); + fprintf(stderr, "%s: %s\n", str, buf); return 0; } #endif + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |