summaryrefslogtreecommitdiffstats
path: root/generic/tclIO.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclIO.c')
-rw-r--r--generic/tclIO.c8841
1 files changed, 5116 insertions, 3725 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 15ac94f..2ece2f4 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -1,4 +1,4 @@
-/*
+/*
* tclIO.c --
*
* This file provides the generic portions (those that are the same on
@@ -7,64 +7,38 @@
* Copyright (c) 1998-2000 Ajuba Solutions
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
*
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
*/
#include "tclInt.h"
-#include "tclPort.h"
#include "tclIO.h"
#include <assert.h>
-#ifndef TCL_INHERIT_STD_CHANNELS
-#define TCL_INHERIT_STD_CHANNELS 1
-#endif
-
-
/*
- * All static variables used in this file are collected into a single
- * instance of the following structure. For multi-threaded implementations,
- * there is one instance of this structure for each thread.
+ * All static variables used in this file are collected into a single instance
+ * of the following structure. For multi-threaded implementations, there is
+ * one instance of this structure for each thread.
*
- * Notice that different structures with the same name appear in other
- * files. The structure defined below is used in this file only.
+ * Notice that different structures with the same name appear in other files.
+ * The structure defined below is used in this file only.
*/
typedef struct ThreadSpecificData {
-
- /*
- * This variable holds the list of nested ChannelHandlerEventProc
- * invocations.
- */
NextChannelHandler *nestedHandlerPtr;
-
- /*
- * List of all channels currently open, indexed by ChannelState,
- * as only one ChannelState exists per set of stacked channels.
- */
- ChannelState *firstCSPtr;
-#ifdef oldcode
- /*
- * Has a channel exit handler been created yet?
- */
- int channelExitHandlerCreated;
-
- /*
- * Has the channel event source been created and registered with the
- * notifier?
- */
- int channelEventSourceCreated;
-#endif
- /*
- * Static variables to hold channels for stdin, stdout and stderr.
- */
- Tcl_Channel stdinChannel;
+ /* This variable holds the list of nested
+ * ChannelHandlerEventProc invocations. */
+ ChannelState *firstCSPtr; /* List of all channels currently open,
+ * indexed by ChannelState, as only one
+ * ChannelState exists per set of stacked
+ * channels. */
+ Tcl_Channel stdinChannel; /* Static variable for the stdin channel. */
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;
-
+ Tcl_Encoding binaryEncoding;
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;
@@ -73,86 +47,181 @@ static Tcl_ThreadDataKey dataKey;
* Static functions in this file:
*/
-static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length));
-static void ChannelTimerProc _ANSI_ARGS_((
- ClientData clientData));
-static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr,
- int direction));
-static int CheckFlush _ANSI_ARGS_((Channel *chanPtr,
- ChannelBuffer *bufPtr, int newlineFlag));
-static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
- ChannelState *statePtr));
-static void CheckForStdChannelsBeingClosed _ANSI_ARGS_((
- Tcl_Channel chan));
-static void CleanupChannelHandlers _ANSI_ARGS_((
- Tcl_Interp *interp, Channel *chanPtr));
-static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int errorCode));
-static void CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr,
- Tcl_Encoding encoding));
-static int CopyAndTranslateBuffer _ANSI_ARGS_((
- ChannelState *statePtr, char *result,
- int space));
-static int CopyBuffer _ANSI_ARGS_((
- Channel *chanPtr, char *result, int space));
-static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
-static void CopyEventProc _ANSI_ARGS_((ClientData clientData,
- int mask));
-static void CreateScriptRecord _ANSI_ARGS_((
- Tcl_Interp *interp, Channel *chanPtr,
- int mask, Tcl_Obj *scriptPtr));
-static void DeleteChannelTable _ANSI_ARGS_((
- ClientData clientData, Tcl_Interp *interp));
-static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mask));
-static int DetachChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Channel chan));
-static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr,
- int discardSavedBuffers));
-static void DiscardOutputQueued _ANSI_ARGS_((
- ChannelState *chanPtr));
-static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
- int slen));
-static int DoWrite _ANSI_ARGS_((Channel *chanPtr, CONST char *src,
- int srcLen));
-static int DoReadChars _ANSI_ARGS_ ((Channel* chan,
- Tcl_Obj* objPtr, int toRead, int appendFlag));
-static int DoWriteChars _ANSI_ARGS_ ((Channel* chan,
- CONST char* src, int len));
-static int FilterInputBytes _ANSI_ARGS_((Channel *chanPtr,
- GetsState *statePtr));
-static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int calledFromAsyncFlush));
-static Tcl_HashTable * GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
-static int GetInput _ANSI_ARGS_((Channel *chanPtr));
-static int HaveVersion _ANSI_ARGS_((Tcl_ChannelType *typePtr,
- Tcl_ChannelTypeVersion minimumVersion));
-static void PeekAhead _ANSI_ARGS_((Channel *chanPtr,
- char **dstEndPtr, GetsState *gsPtr));
-static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr,
- Tcl_Obj *objPtr, int charsLeft,
- int *offsetPtr));
-static int ReadChars _ANSI_ARGS_((ChannelState *statePtr,
- Tcl_Obj *objPtr, int charsLeft,
- int *offsetPtr, int *factorPtr));
-static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr,
- ChannelBuffer *bufPtr, int mustDiscard));
-static int StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr,
- int mode));
-static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mode));
-static void StopCopy _ANSI_ARGS_((CopyState *csPtr));
-static int TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr,
- char *dst, CONST char *src,
- int *dstLenPtr, int *srcLenPtr));
-static int TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr,
- char *dst, CONST char *src,
- int *dstLenPtr, int *srcLenPtr));
-static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
-static int WriteBytes _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
-static int WriteChars _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
+static ChannelBuffer * AllocChannelBuffer(int length);
+static void ChannelTimerProc(ClientData clientData);
+static int CheckChannelErrors(ChannelState *statePtr,
+ int direction);
+static int CheckFlush(Channel *chanPtr, ChannelBuffer *bufPtr,
+ int newlineFlag);
+static int CheckForDeadChannel(Tcl_Interp *interp,
+ ChannelState *statePtr);
+static void CheckForStdChannelsBeingClosed(Tcl_Channel chan);
+static void CleanupChannelHandlers(Tcl_Interp *interp,
+ Channel *chanPtr);
+static int CloseChannel(Tcl_Interp *interp, Channel *chanPtr,
+ int errorCode);
+static void CommonGetsCleanup(Channel *chanPtr);
+static int CopyAndTranslateBuffer(ChannelState *statePtr,
+ char *result, int space);
+static int CopyBuffer(Channel *chanPtr, char *result, int space);
+static int CopyData(CopyState *csPtr, int mask);
+static void CopyEventProc(ClientData clientData, int mask);
+static void CreateScriptRecord(Tcl_Interp *interp,
+ Channel *chanPtr, int mask, Tcl_Obj *scriptPtr);
+static void DeleteChannelTable(ClientData clientData,
+ Tcl_Interp *interp);
+static void DeleteScriptRecord(Tcl_Interp *interp,
+ Channel *chanPtr, int mask);
+static int DetachChannel(Tcl_Interp *interp, Tcl_Channel chan);
+static void DiscardInputQueued(ChannelState *statePtr,
+ int discardSavedBuffers);
+static void DiscardOutputQueued(ChannelState *chanPtr);
+static int DoRead(Channel *chanPtr, char *srcPtr, int slen);
+static int DoWrite(Channel *chanPtr, const char *src, int srcLen);
+static int DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
+ int appendFlag);
+static int DoWriteChars(Channel *chan, const char *src, int len);
+static int FilterInputBytes(Channel *chanPtr,
+ GetsState *statePtr);
+static int FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
+ int calledFromAsyncFlush);
+static int TclGetsObjBinary(Tcl_Channel chan, Tcl_Obj *objPtr);
+static void FreeBinaryEncoding(ClientData clientData);
+static Tcl_HashTable * GetChannelTable(Tcl_Interp *interp);
+static int GetInput(Channel *chanPtr);
+static int HaveVersion(const Tcl_ChannelType *typePtr,
+ Tcl_ChannelTypeVersion minimumVersion);
+static void PeekAhead(Channel *chanPtr, char **dstEndPtr,
+ GetsState *gsPtr);
+static int ReadBytes(ChannelState *statePtr, Tcl_Obj *objPtr,
+ int charsLeft, int *offsetPtr);
+static int ReadChars(ChannelState *statePtr, Tcl_Obj *objPtr,
+ int charsLeft, int *offsetPtr, int *factorPtr);
+static void RecycleBuffer(ChannelState *statePtr,
+ ChannelBuffer *bufPtr, int mustDiscard);
+static int StackSetBlockMode(Channel *chanPtr, int mode);
+static int SetBlockMode(Tcl_Interp *interp, Channel *chanPtr,
+ int mode);
+static void StopCopy(CopyState *csPtr);
+static int TranslateInputEOL(ChannelState *statePtr, char *dst,
+ const char *src, int *dstLenPtr, int *srcLenPtr);
+static int TranslateOutputEOL(ChannelState *statePtr, char *dst,
+ const char *src, int *dstLenPtr, int *srcLenPtr);
+static void UpdateInterest(Channel *chanPtr);
+static int WriteBytes(Channel *chanPtr, const char *src,
+ int srcLen);
+static int WriteChars(Channel *chanPtr, const char *src,
+ int srcLen);
+static Tcl_Obj * FixLevelCode(Tcl_Obj *msg);
+static void SpliceChannel(Tcl_Channel chan);
+static void CutChannel(Tcl_Channel chan);
+
+/*
+ * Simplifying helper macros. All may use their argument(s) multiple times.
+ * The ANSI C "prototypes" for the macros are listed below, together with a
+ * short description of what the macro does.
+ *
+ * --------------------------------------------------------------------------
+ * int BytesLeft(ChannelBuffer *bufPtr)
+ *
+ * Returns the number of bytes of data remaining in the buffer.
+ *
+ * int SpaceLeft(ChannelBuffer *bufPtr)
+ *
+ * Returns the number of bytes of space remaining at the end of the
+ * buffer.
+ *
+ * int IsBufferReady(ChannelBuffer *bufPtr)
+ *
+ * Returns whether a buffer has bytes available within it.
+ *
+ * int IsBufferEmpty(ChannelBuffer *bufPtr)
+ *
+ * Returns whether a buffer is entirely empty. Note that this is not the
+ * inverse of the above operation; trying to merge the two seems to lead
+ * to occasional crashes...
+ *
+ * int IsBufferFull(ChannelBuffer *bufPtr)
+ *
+ * Returns whether more data can be added to a buffer.
+ *
+ * int IsBufferOverflowing(ChannelBuffer *bufPtr)
+ *
+ * Returns whether a buffer has more data in it than it should.
+ *
+ * char *InsertPoint(ChannelBuffer *bufPtr)
+ *
+ * Returns a pointer to where characters should be added to the buffer.
+ *
+ * char *RemovePoint(ChannelBuffer *bufPtr)
+ *
+ * Returns a pointer to where characters should be removed from the
+ * buffer.
+ * --------------------------------------------------------------------------
+ */
+
+#define BytesLeft(bufPtr) ((bufPtr)->nextAdded - (bufPtr)->nextRemoved)
+
+#define SpaceLeft(bufPtr) ((bufPtr)->bufLength - (bufPtr)->nextAdded)
+
+#define IsBufferReady(bufPtr) ((bufPtr)->nextAdded > (bufPtr)->nextRemoved)
+
+#define IsBufferEmpty(bufPtr) ((bufPtr)->nextAdded == (bufPtr)->nextRemoved)
+
+#define IsBufferFull(bufPtr) ((bufPtr)->nextAdded >= (bufPtr)->bufLength)
+
+#define IsBufferOverflowing(bufPtr) ((bufPtr)->nextAdded > (bufPtr)->bufLength)
+
+#define InsertPoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextAdded)
+
+#define RemovePoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextRemoved)
+
+/*
+ * For working with channel state flag bits.
+ */
+
+#define SetFlag(statePtr, flag) ((statePtr)->flags |= (flag))
+#define ResetFlag(statePtr, flag) ((statePtr)->flags &= ~(flag))
+
+/*
+ * Macro for testing whether a string (in optionName, length len) matches a
+ * value (prefix matching rules). Arguments are the minimum length to match
+ * and the value to match against. (Can't use Tcl_GetIndexFromObj as this is
+ * used in a situation where no objects are available.)
+ */
+
+#define HaveOpt(minLength, nameString) \
+ ((len > (minLength)) && (optionName[1] == (nameString)[1]) \
+ && (strncmp(optionName, (nameString), len) == 0))
+
+/*
+ * The ChannelObjType type. We actually store the ChannelState structure
+ * as that lives longest and we want to return the bottomChanPtr when
+ * requested (consistent with Tcl_GetChannel). The setFromAny and
+ * updateString can be NULL as they should not be called.
+ */
+
+static void DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
+static int SetChannelFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
+static void UpdateStringOfChannel(Tcl_Obj *objPtr);
+static void FreeChannelIntRep(Tcl_Obj *objPtr);
+
+static Tcl_ObjType tclChannelType = {
+ "channel", /* name for this type */
+ FreeChannelIntRep, /* freeIntRepProc */
+ DupChannelIntRep, /* dupIntRepProc */
+ NULL, /* updateStringProc UpdateStringOfChannel */
+ NULL /* setFromAnyProc SetChannelFromAny */
+};
+
+#define GET_CHANNELSTATE(objPtr) \
+ ((ChannelState *) (objPtr)->internalRep.otherValuePtr)
+#define SET_CHANNELSTATE(objPtr, storePtr) \
+ ((objPtr)->internalRep.otherValuePtr = (void *) (storePtr))
+#define GET_CHANNELINTERP(objPtr) \
+ ((Interp *) (objPtr)->internalRep.twoPtrValue.ptr2)
+#define SET_CHANNELINTERP(objPtr, storePtr) \
+ ((objPtr)->internalRep.twoPtrValue.ptr2 = (void *) (storePtr))
#define BUSY_STATE(st,fl) \
((((st)->csPtrR) && ((fl) & TCL_READABLE)) || \
@@ -166,7 +235,7 @@ static int WriteChars _ANSI_ARGS_((Channel *chanPtr,
* TclInitIOSubsystem --
*
* Initialize all resources used by this subsystem on a per-process
- * basis.
+ * basis.
*
* Results:
* None.
@@ -178,23 +247,24 @@ static int WriteChars _ANSI_ARGS_((Channel *chanPtr,
*/
void
-TclInitIOSubsystem()
+TclInitIOSubsystem(void)
{
/*
- * 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-thread
- * 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.
@@ -215,23 +285,21 @@ TclFinalizeIOSubsystem(void)
int active = 1; /* Flag == 1 while there's still work to do */
/*
- * Walk all channel state structures known to this thread and
- * close corresponding channels.
+ * Walk all channel state structures known to this thread and close
+ * corresponding channels.
*/
while (active) {
-
/*
- * Iterate through the open channel list, and find the first
- * channel that isn't dead. We start from the head of the list
- * each time, because the close action on one channel can close
- * others.
+ * Iterate through the open channel list, and find the first channel
+ * that isn't dead. We start from the head of the list each time,
+ * because the close action on one channel can close others.
*/
active = 0;
for (statePtr = tsdPtr->firstCSPtr;
- statePtr != NULL;
- statePtr = statePtr->nextCSPtr) {
+ statePtr != NULL;
+ statePtr = statePtr->nextCSPtr) {
chanPtr = statePtr->topChanPtr;
if (!(statePtr->flags & (CHANNEL_INCLOSE|CHANNEL_CLOSED|CHANNEL_DEAD))) {
active = 1;
@@ -240,67 +308,65 @@ TclFinalizeIOSubsystem(void)
}
/*
- * We've found a live channel. Close it.
+ * We've found a live channel. Close it.
*/
if (active) {
-
/*
- * 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,
- "-blocking", "on");
-
+ "-blocking", "on");
+
if ((chanPtr == (Channel *) tsdPtr->stdinChannel) ||
- (chanPtr == (Channel *) tsdPtr->stdoutChannel) ||
- (chanPtr == (Channel *) tsdPtr->stderrChannel)) {
+ (chanPtr == (Channel *) tsdPtr->stdoutChannel) ||
+ (chanPtr == (Channel *) tsdPtr->stderrChannel)) {
/*
- * Decrement the refcount which was earlier artificially
+ * Decrement the refcount which was earlier artificially
* bumped up to keep the channel from being closed.
*/
-
+
statePtr->refCount--;
}
-
+
if (statePtr->refCount <= 0) {
/*
- * Close it only if the refcount indicates that the channel
- * is not referenced from any interpreter. If it is, that
+ * Close it only if the refcount indicates that the channel is
+ * not referenced from any interpreter. If it is, that
* interpreter will close the channel when it gets destroyed.
*/
-
+
(void) Tcl_Close(NULL, (Tcl_Channel) chanPtr);
} else {
/*
* The refcount is greater than zero, so flush the channel.
*/
-
+
Tcl_Flush((Tcl_Channel) chanPtr);
-
+
/*
- * Call the device driver to actually close the underlying
+ * Call the device driver to actually close the underlying
* device for this channel.
*/
-
+
if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
(chanPtr->typePtr->closeProc)(chanPtr->instanceData, NULL);
} else {
(chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
- NULL, 0);
+ NULL, 0);
}
-
+
/*
- * Finally, we clean up the fields in the channel data
- * structure since all of them have been deleted already.
- * We mark the channel with CHANNEL_DEAD to prevent any
- * further IO operations
- * on it.
+ * Finally, we clean up the fields in the channel data
+ * structure since all of them have been deleted already. We
+ * mark the channel with CHANNEL_DEAD to prevent any further
+ * IO operations on it.
*/
-
+
chanPtr->instanceData = NULL;
- statePtr->flags |= CHANNEL_DEAD;
+ SetFlag(statePtr, CHANNEL_DEAD);
}
}
}
@@ -308,15 +374,14 @@ TclFinalizeIOSubsystem(void)
TclpFinalizeSockets();
TclpFinalizePipes();
}
-
/*
*----------------------------------------------------------------------
*
* Tcl_SetStdChannel --
*
- * This function is used to change the channels that are used
- * for stdin/stdout/stderr in new interpreters.
+ * This function is used to change the channels that are used for
+ * stdin/stdout/stderr in new interpreters.
*
* Results:
* None
@@ -328,24 +393,24 @@ TclFinalizeIOSubsystem(void)
*/
void
-Tcl_SetStdChannel(channel, type)
- Tcl_Channel channel;
- int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+Tcl_SetStdChannel(
+ Tcl_Channel channel,
+ int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
switch (type) {
- case TCL_STDIN:
- tsdPtr->stdinInitialized = 1;
- tsdPtr->stdinChannel = channel;
- break;
- case TCL_STDOUT:
- tsdPtr->stdoutInitialized = 1;
- tsdPtr->stdoutChannel = channel;
- break;
- case TCL_STDERR:
- tsdPtr->stderrInitialized = 1;
- tsdPtr->stderrChannel = channel;
- break;
+ case TCL_STDIN:
+ tsdPtr->stdinInitialized = 1;
+ tsdPtr->stdinChannel = channel;
+ break;
+ case TCL_STDOUT:
+ tsdPtr->stdoutInitialized = 1;
+ tsdPtr->stdoutChannel = channel;
+ break;
+ case TCL_STDERR:
+ tsdPtr->stderrInitialized = 1;
+ tsdPtr->stderrChannel = channel;
+ break;
}
}
@@ -360,71 +425,67 @@ 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.
*
*----------------------------------------------------------------------
*/
+
Tcl_Channel
-Tcl_GetStdChannel(type)
- int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+Tcl_GetStdChannel(
+ int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
{
Tcl_Channel channel = NULL;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
/*
- * If the channels were not created yet, create them now and
- * store them in the static variables.
+ * If the channels were not created yet, create them now and store them in
+ * the static variables.
*/
switch (type) {
- case TCL_STDIN:
- if (!tsdPtr->stdinInitialized) {
- tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN);
- tsdPtr->stdinInitialized = 1;
+ 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.
- */
-
- if (tsdPtr->stdinChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stdinChannel);
- }
- }
- channel = tsdPtr->stdinChannel;
- break;
- case TCL_STDOUT:
- if (!tsdPtr->stdoutInitialized) {
- tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
- tsdPtr->stdoutInitialized = 1;
- if (tsdPtr->stdoutChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stdoutChannel);
- }
- }
- channel = tsdPtr->stdoutChannel;
- break;
- case TCL_STDERR:
- if (!tsdPtr->stderrInitialized) {
- tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
- tsdPtr->stderrInitialized = 1;
- if (tsdPtr->stderrChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stderrChannel);
- }
- }
- channel = tsdPtr->stderrChannel;
- break;
+ /*
+ * 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 != NULL) {
+ Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
+ }
+ }
+ channel = tsdPtr->stdinChannel;
+ break;
+ case TCL_STDOUT:
+ if (!tsdPtr->stdoutInitialized) {
+ tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
+ tsdPtr->stdoutInitialized = 1;
+ if (tsdPtr->stdoutChannel != NULL) {
+ Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
+ }
+ }
+ channel = tsdPtr->stdoutChannel;
+ break;
+ case TCL_STDERR:
+ if (!tsdPtr->stderrInitialized) {
+ tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
+ tsdPtr->stderrInitialized = 1;
+ if (tsdPtr->stderrChannel != NULL) {
+ Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
+ }
+ }
+ channel = tsdPtr->stderrChannel;
+ break;
}
return channel;
}
-
/*
*----------------------------------------------------------------------
@@ -438,27 +499,27 @@ 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_CloseProc *proc; /* The callback routine to call when the
- * channel will be closed. */
- ClientData clientData; /* Arbitrary data to pass to the
- * close callback. */
+Tcl_CreateCloseHandler(
+ Tcl_Channel chan, /* The channel for which to create the close
+ * callback. */
+ Tcl_CloseProc *proc, /* The callback routine to call when the
+ * channel will be closed. */
+ ClientData clientData) /* Arbitrary data to pass to the close
+ * callback. */
{
ChannelState *statePtr;
CloseCallback *cbPtr;
statePtr = ((Channel *) chan)->state;
- cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
+ cbPtr = (CloseCallback *) ckalloc(sizeof(CloseCallback));
cbPtr->proc = proc;
cbPtr->clientData = clientData;
@@ -471,45 +532,43 @@ 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_CloseProc *proc; /* The procedure for the callback to
- * remove. */
- ClientData clientData; /* The callback data for the callback
- * to remove. */
+Tcl_DeleteCloseHandler(
+ Tcl_Channel chan, /* The channel for which to cancel the close
+ * callback. */
+ Tcl_CloseProc *proc, /* The procedure for the callback to
+ * remove. */
+ ClientData clientData) /* The callback data for the callback to
+ * remove. */
{
ChannelState *statePtr;
CloseCallback *cbPtr, *cbPrevPtr;
statePtr = ((Channel *) chan)->state;
- for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
- cbPtr != (CloseCallback *) NULL;
- cbPtr = cbPtr->nextPtr) {
- if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
- if (cbPrevPtr == (CloseCallback *) NULL) {
- statePtr->closeCbPtr = cbPtr->nextPtr;
- }
- ckfree((char *) cbPtr);
- break;
- } else {
- cbPrevPtr = cbPtr;
- }
+ for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = NULL;
+ cbPtr != NULL; cbPtr = cbPtr->nextPtr) {
+ if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
+ if (cbPrevPtr == NULL) {
+ statePtr->closeCbPtr = cbPtr->nextPtr;
+ }
+ ckfree((char *) cbPtr);
+ break;
+ } else {
+ cbPrevPtr = cbPtr;
+ }
}
}
@@ -518,58 +577,53 @@ 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.
*
*----------------------------------------------------------------------
*/
static Tcl_HashTable *
-GetChannelTable(interp)
- Tcl_Interp *interp;
+GetChannelTable(
+ Tcl_Interp *interp)
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_Channel stdinChan, stdoutChan, stderrChan;
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
- hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable));
- Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
-
- (void) Tcl_SetAssocData(interp, "tclIO",
- (Tcl_InterpDeleteProc *) DeleteChannelTable,
- (ClientData) hTblPtr);
-
- /*
- * If the interpreter is trusted (not "safe"), insert channels
- * for stdin, stdout and stderr (possibly creating them in the
- * process).
- */
-
- if (Tcl_IsSafe(interp) == 0) {
- stdinChan = Tcl_GetStdChannel(TCL_STDIN);
- if (stdinChan != NULL) {
- Tcl_RegisterChannel(interp, stdinChan);
- }
- stdoutChan = Tcl_GetStdChannel(TCL_STDOUT);
- if (stdoutChan != NULL) {
- Tcl_RegisterChannel(interp, stdoutChan);
- }
- stderrChan = Tcl_GetStdChannel(TCL_STDERR);
- if (stderrChan != NULL) {
- Tcl_RegisterChannel(interp, stderrChan);
- }
- }
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+ if (hTblPtr == NULL) {
+ hTblPtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
+ Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
+ Tcl_SetAssocData(interp, "tclIO",
+ (Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr);
+ /*
+ * If the interpreter is trusted (not "safe"), insert channels for
+ * stdin, stdout and stderr (possibly creating them in the process).
+ */
+
+ if (Tcl_IsSafe(interp) == 0) {
+ stdinChan = Tcl_GetStdChannel(TCL_STDIN);
+ if (stdinChan != NULL) {
+ Tcl_RegisterChannel(interp, stdinChan);
+ }
+ stdoutChan = Tcl_GetStdChannel(TCL_STDOUT);
+ if (stdoutChan != NULL) {
+ Tcl_RegisterChannel(interp, stdoutChan);
+ }
+ stderrChan = Tcl_GetStdChannel(TCL_STDERR);
+ if (stderrChan != NULL) {
+ Tcl_RegisterChannel(interp, stderrChan);
+ }
+ }
}
return hTblPtr;
}
@@ -580,9 +634,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.
@@ -596,9 +649,9 @@ GetChannelTable(interp)
*/
static void
-DeleteChannelTable(clientData, interp)
- ClientData clientData; /* The per-interpreter data structure. */
- Tcl_Interp *interp; /* The interpreter being deleted. */
+DeleteChannelTable(
+ ClientData clientData, /* The per-interpreter data structure. */
+ Tcl_Interp *interp) /* The interpreter being deleted. */
{
Tcl_HashTable *hTblPtr; /* The hash table. */
Tcl_HashSearch hSearch; /* Search variable. */
@@ -606,63 +659,61 @@ 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
- * registered, to delete the ones that refer
- * to the interpreter being deleted. */
+ /* Variables to loop over all channel events
+ * registered, to delete the ones that refer
+ * to the interpreter being deleted. */
/*
* Delete all the registered channels - this will close channels whose
* refcount reaches zero.
*/
-
- hTblPtr = (Tcl_HashTable *) clientData;
- for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
- hPtr != (Tcl_HashEntry *) NULL;
- hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
- chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
+ hTblPtr = clientData;
+ for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
+ hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
+ chanPtr = Tcl_GetHashValue(hPtr);
statePtr = chanPtr->state;
- /*
- * Remove any fileevents registered in this interpreter.
- */
-
- for (sPtr = statePtr->scriptRecordPtr,
- prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
- nextPtr = sPtr->nextPtr;
- if (sPtr->interp == interp) {
- if (prevPtr == (EventScriptRecord *) NULL) {
- statePtr->scriptRecordPtr = nextPtr;
- } else {
- prevPtr->nextPtr = nextPtr;
- }
-
- Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
- TclChannelEventScriptInvoker, (ClientData) sPtr);
-
- Tcl_DecrRefCount(sPtr->scriptPtr);
- ckfree((char *) sPtr);
- } else {
- prevPtr = sPtr;
- }
- }
-
- /*
- * Cannot call Tcl_UnregisterChannel because that procedure calls
- * Tcl_GetAssocData to get the channel table, which might already
- * be inaccessible from the interpreter structure. Instead, we
- * emulate the behavior of Tcl_UnregisterChannel directly here.
- */
-
- Tcl_DeleteHashEntry(hPtr);
- statePtr->refCount--;
- if (statePtr->refCount <= 0) {
- if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
- (void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
- }
- }
+ /*
+ * Remove any fileevents registered in this interpreter.
+ */
+
+ for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+ sPtr != NULL; sPtr = nextPtr) {
+ nextPtr = sPtr->nextPtr;
+ if (sPtr->interp == interp) {
+ if (prevPtr == NULL) {
+ statePtr->scriptRecordPtr = nextPtr;
+ } else {
+ prevPtr->nextPtr = nextPtr;
+ }
+
+ Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+ TclChannelEventScriptInvoker, (ClientData) sPtr);
+
+ TclDecrRefCount(sPtr->scriptPtr);
+ ckfree((char *) sPtr);
+ } else {
+ prevPtr = sPtr;
+ }
+ }
+
+ /*
+ * Cannot call Tcl_UnregisterChannel because that procedure calls
+ * Tcl_GetAssocData to get the channel table, which might already be
+ * inaccessible from the interpreter structure. Instead, we emulate
+ * the behavior of Tcl_UnregisterChannel directly here.
+ */
+
+ Tcl_DeleteHashEntry(hPtr);
+ SetFlag(statePtr, CHANNEL_TAINTED);
+ statePtr->refCount--;
+ if (statePtr->refCount <= 0) {
+ if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
+ (void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
+ }
+ }
+
}
Tcl_DeleteHashTable(hTblPtr);
ckfree((char *) hTblPtr);
@@ -674,11 +725,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.
@@ -691,32 +742,32 @@ DeleteChannelTable(clientData, interp)
*/
static void
-CheckForStdChannelsBeingClosed(chan)
- Tcl_Channel chan;
+CheckForStdChannelsBeingClosed(
+ Tcl_Channel chan)
{
ChannelState *statePtr = ((Channel *) chan)->state;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) {
- if (statePtr->refCount < 2) {
- statePtr->refCount = 0;
- tsdPtr->stdinChannel = NULL;
- return;
- }
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
+ tsdPtr->stdinChannel = NULL;
+ return;
+ }
} else if ((chan == tsdPtr->stdoutChannel)
&& (tsdPtr->stdoutInitialized)) {
- if (statePtr->refCount < 2) {
- statePtr->refCount = 0;
- tsdPtr->stdoutChannel = NULL;
- return;
- }
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
+ tsdPtr->stdoutChannel = NULL;
+ return;
+ }
} else if ((chan == tsdPtr->stderrChannel)
&& (tsdPtr->stderrInitialized)) {
- if (statePtr->refCount < 2) {
- statePtr->refCount = 0;
- tsdPtr->stderrChannel = NULL;
- return;
- }
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
+ tsdPtr->stderrChannel = NULL;
+ return;
+ }
}
}
@@ -725,27 +776,28 @@ CheckForStdChannelsBeingClosed(chan)
*
* Tcl_IsStandardChannel --
*
- * Test if the given channel is a standard channel. No attempt
- * is made to check if the channel or the standard channels
- * are initialized or otherwise valid.
+ * Test if the given channel is a standard channel. No attempt is made to
+ * check if the channel or the standard channels are initialized or
+ * otherwise valid.
*
* Results:
* Returns 1 if true, 0 if false.
*
* Side effects:
- * None.
+ * None.
*
*----------------------------------------------------------------------
*/
-int
-Tcl_IsStandardChannel(chan)
- Tcl_Channel chan; /* Channel to check. */
+
+int
+Tcl_IsStandardChannel(
+ Tcl_Channel chan) /* Channel to check. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- if ((chan == tsdPtr->stdinChannel)
- || (chan == tsdPtr->stdoutChannel)
- || (chan == tsdPtr->stderrChannel)) {
+ if ((chan == tsdPtr->stdinChannel)
+ || (chan == tsdPtr->stdoutChannel)
+ || (chan == tsdPtr->stderrChannel)) {
return 1;
} else {
return 0;
@@ -758,8 +810,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.
@@ -771,41 +823,41 @@ Tcl_IsStandardChannel(chan)
*/
void
-Tcl_RegisterChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which to add the channel. */
- Tcl_Channel chan; /* The channel to add to this interpreter
- * channel table. */
+Tcl_RegisterChannel(
+ Tcl_Interp *interp, /* Interpreter in which to add the channel. */
+ Tcl_Channel chan) /* The channel to add to this interpreter
+ * channel table. */
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
- int new; /* Is the hash entry new or does it exist? */
+ int isNew; /* Is the hash entry new or does it exist? */
Channel *chanPtr; /* The actual channel. */
ChannelState *statePtr; /* State of the actual channel. */
/*
- * Always (un)register bottom-most channel in the stack. This makes
+ * Always (un)register bottom-most channel in the stack. This makes
* management of the channel list easier because no manipulation is
* necessary during (un)stack operation.
*/
+
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- if (statePtr->channelName == (CONST char *) NULL) {
- panic("Tcl_RegisterChannel: channel without name");
+ if (statePtr->channelName == NULL) {
+ Tcl_Panic("Tcl_RegisterChannel: channel without name");
}
- if (interp != (Tcl_Interp *) NULL) {
- hTblPtr = GetChannelTable(interp);
- hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new);
- if (new == 0) {
- if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
- return;
- }
+ if (interp != NULL) {
+ hTblPtr = GetChannelTable(interp);
+ hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &isNew);
+ if (!isNew) {
+ if (chan == Tcl_GetHashValue(hPtr)) {
+ return;
+ }
- panic("Tcl_RegisterChannel: duplicate channel names");
- }
- Tcl_SetHashValue(hPtr, (ClientData) chanPtr);
+ Tcl_Panic("Tcl_RegisterChannel: duplicate channel names");
+ }
+ Tcl_SetHashValue(hPtr, chanPtr);
}
-
statePtr->refCount++;
}
@@ -816,19 +868,19 @@ Tcl_RegisterChannel(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. (This all happens in the Tcl_DetachChannel helper
+ * reference count. (This all happens in the Tcl_DetachChannel helper
* function).
- *
- * Finally, if the reference count of the channel drops to zero,
- * it is deleted.
+ *
+ * Finally, if the reference count of the channel drops to zero, it is
+ * deleted.
*
* Results:
* A standard Tcl result.
*
* Side effects:
- * Calls Tcl_DetachChannel which deletes the hash entry for a channel
+ * Calls Tcl_DetachChannel which deletes the hash entry for a channel
* associated with an interpreter.
- *
+ *
* May delete the channel, which can have a variety of consequences,
* especially if we are forced to close the channel.
*
@@ -836,27 +888,26 @@ Tcl_RegisterChannel(interp, chan)
*/
int
-Tcl_UnregisterChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+Tcl_UnregisterChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
ChannelState *statePtr; /* State of the real channel. */
statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
-
+
if (statePtr->flags & CHANNEL_INCLOSE) {
- if (interp != (Tcl_Interp*) NULL) {
- Tcl_AppendResult(interp,
- "Illegal recursive call to close through close-handler of channel",
- (char *) NULL);
+ if (interp != NULL) {
+ Tcl_AppendResult(interp, "Illegal recursive call to close "
+ "through close-handler of channel", NULL);
}
- return TCL_ERROR;
+ return TCL_ERROR;
}
-
+
if (DetachChannel(interp, chan) != TCL_OK) {
- return TCL_OK;
+ return TCL_OK;
}
-
+
statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
/*
@@ -874,29 +925,30 @@ Tcl_UnregisterChannel(interp, chan)
*/
if (statePtr->refCount <= 0) {
+ /*
+ * Ensure that if there is another buffer, it gets flushed whether or
+ * not we are doing a background flush.
+ */
- /*
- * Ensure that if there is another buffer, it gets flushed
- * whether or not we are doing a background flush.
- */
-
- if ((statePtr->curOutPtr != NULL) &&
- (statePtr->curOutPtr->nextAdded >
- statePtr->curOutPtr->nextRemoved)) {
- statePtr->flags |= BUFFER_READY;
- }
+ if ((statePtr->curOutPtr != NULL) &&
+ IsBufferReady(statePtr->curOutPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
+ }
Tcl_Preserve((ClientData)statePtr);
- if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
- /* We don't want to re-enter Tcl_Close */
+ if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
+ /*
+ * We don't want to re-enter Tcl_Close().
+ */
+
if (!(statePtr->flags & CHANNEL_CLOSED)) {
if (Tcl_Close(interp, chan) != TCL_OK) {
- statePtr->flags |= CHANNEL_CLOSED;
+ SetFlag(statePtr, CHANNEL_CLOSED);
Tcl_Release((ClientData)statePtr);
return TCL_ERROR;
}
}
- }
- statePtr->flags |= CHANNEL_CLOSED;
+ }
+ SetFlag(statePtr, CHANNEL_CLOSED);
Tcl_Release((ClientData)statePtr);
}
return TCL_OK;
@@ -909,45 +961,42 @@ 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.
+ * A standard Tcl result. If the channel is not currently registered with
+ * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ * However no error messages are left in the interp's result.
*
* Side effects:
- * Deletes the hash entry for a channel associated with an
- * interpreter.
+ * Deletes the hash entry for a channel associated with an interpreter.
*
*----------------------------------------------------------------------
*/
int
-Tcl_DetachChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+Tcl_DetachChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
if (Tcl_IsStandardChannel(chan)) {
- return TCL_ERROR;
+ return TCL_ERROR;
}
-
+
return DetachChannel(interp, chan);
}
@@ -958,28 +1007,26 @@ 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.
+ * A standard Tcl result. If the channel is not currently registered with
+ * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ * However no error messages are left in the interp's result.
*
* Side effects:
- * Deletes the hash entry for a channel associated with an
- * interpreter.
+ * Deletes the hash entry for a channel associated with an interpreter.
*
*----------------------------------------------------------------------
*/
static int
-DetachChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+DetachChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
@@ -987,43 +1034,44 @@ DetachChannel(interp, chan)
ChannelState *statePtr; /* State of the real channel. */
/*
- * Always (un)register bottom-most channel in the stack. This makes
+ * Always (un)register bottom-most channel in the stack. This makes
* management of the channel list easier because no manipulation is
* necessary during (un)stack operation.
*/
+
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- if (interp != (Tcl_Interp *) NULL) {
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
+ if (interp != NULL) {
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+ if (hTblPtr == NULL) {
return TCL_ERROR;
}
hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
- if (hPtr == (Tcl_HashEntry *) NULL) {
+ if (hPtr == NULL) {
return TCL_ERROR;
}
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
return TCL_ERROR;
}
Tcl_DeleteHashEntry(hPtr);
+ SetFlag(statePtr, CHANNEL_TAINTED);
/*
- * Remove channel handlers that refer to this interpreter, so that they
- * will not be present if the actual close is delayed and more events
- * happen on the channel. This may occur if the channel is shared
- * between several interpreters, or if the channel has async
+ * Remove channel handlers that refer to this interpreter, so that
+ * they will not be present if the actual close is delayed and more
+ * events happen on the channel. This may occur if the channel is
+ * shared between several interpreters, or if the channel has async
* flushing active.
*/
-
+
CleanupChannelHandlers(interp, chanPtr);
}
statePtr->refCount--;
-
+
return TCL_OK;
}
-
/*
*---------------------------------------------------------------------------
@@ -1035,9 +1083,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.
@@ -1046,26 +1094,26 @@ DetachChannel(interp, chan)
*/
Tcl_Channel
-Tcl_GetChannel(interp, chanName, modePtr)
- Tcl_Interp *interp; /* Interpreter in which to find or create
- * the channel. */
- CONST char *chanName; /* The name of the channel. */
- int *modePtr; /* Where to store the mode in which the
- * channel was opened? Will contain an ORed
- * combination of TCL_READABLE and
- * TCL_WRITABLE, if non-NULL. */
+Tcl_GetChannel(
+ Tcl_Interp *interp, /* Interpreter in which to find or create the
+ * channel. */
+ const char *chanName, /* The name of the channel. */
+ int *modePtr) /* Where to store the mode in which the
+ * channel was opened? Will contain an ORed
+ * combination of TCL_READABLE and
+ * TCL_WRITABLE, if non-NULL. */
{
Channel *chanPtr; /* The actual channel. */
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
- CONST char *name; /* Translated name. */
+ const char *name; /* Translated name. */
/*
- * Substitute "stdin", etc. Note that even though we immediately
- * find the channel using Tcl_GetStdChannel, we still need to look
- * it up in the specified interpreter to ensure that it is present
- * in the channel table. Otherwise, safe interpreters would always
- * have access to the standard channels.
+ * Substitute "stdin", etc. Note that even though we immediately find the
+ * channel using Tcl_GetStdChannel, we still need to look it up in the
+ * specified interpreter to ensure that it is present in the channel
+ * table. Otherwise, safe interpreters would always have access to the
+ * standard channels.
*/
name = chanName;
@@ -1085,57 +1133,104 @@ Tcl_GetChannel(interp, chanName, modePtr)
hTblPtr = GetChannelTable(interp);
hPtr = Tcl_FindHashEntry(hTblPtr, name);
- if (hPtr == (Tcl_HashEntry *) NULL) {
- Tcl_AppendResult(interp, "can not find channel named \"",
- chanName, "\"", (char *) NULL);
- return NULL;
+ if (hPtr == NULL) {
+ Tcl_AppendResult(interp, "can not find channel named \"", chanName,
+ "\"", NULL);
+ Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CHANNEL", chanName, NULL);
+ return NULL;
}
/*
- * Always return bottom-most channel in the stack. This one lives
- * the longest - other channels may go away unnoticed.
- * The other APIs compensate where necessary to retrieve the
- * topmost channel again.
+ * Always return bottom-most channel in the stack. This one lives the
+ * longest - other channels may go away unnoticed. The other APIs
+ * compensate where necessary to retrieve the topmost channel again.
*/
- chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
+
+ chanPtr = Tcl_GetHashValue(hPtr);
chanPtr = chanPtr->state->bottomChanPtr;
if (modePtr != NULL) {
- *modePtr = (chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE));
+ *modePtr = (chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE));
}
-
+
return (Tcl_Channel) chanPtr;
}
/*
+ *---------------------------------------------------------------------------
+ *
+ * TclGetChannelFromObj --
+ *
+ * Finds an existing Tcl_Channel structure by name in a given
+ * interpreter. This function is public because it is used by
+ * channel-type-specific functions.
+ *
+ * Results:
+ * A Tcl_Channel or NULL on failure. If failed, interp's result object
+ * contains an error message. *modePtr is filled with the modes in which
+ * the channel was opened.
+ *
+ * Side effects:
+ * None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+TclGetChannelFromObj(
+ Tcl_Interp *interp, /* Interpreter in which to find or create the
+ * channel. */
+ Tcl_Obj *objPtr,
+ Tcl_Channel *channelPtr,
+ int *modePtr, /* Where to store the mode in which the
+ * channel was opened? Will contain an ORed
+ * combination of TCL_READABLE and
+ * TCL_WRITABLE, if non-NULL. */
+ int flags)
+{
+ ChannelState *statePtr;
+
+ if (SetChannelFromAny(interp, objPtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+
+ statePtr = GET_CHANNELSTATE(objPtr);
+ *channelPtr = (Tcl_Channel) (statePtr->bottomChanPtr);
+
+ if (modePtr != NULL) {
+ *modePtr = (statePtr->flags & (TCL_READABLE|TCL_WRITABLE));
+ }
+
+ return TCL_OK;
+}
+
+/*
*----------------------------------------------------------------------
*
* Tcl_CreateChannel --
*
- * Creates a new entry in the hash table for a Tcl_Channel
- * record.
+ * Creates a new entry in the hash table for a Tcl_Channel record.
*
* Results:
* Returns the new Tcl_Channel.
*
* Side effects:
- * Creates a new Tcl_Channel instance and inserts it into the
- * hash table.
+ * Creates a new Tcl_Channel instance and inserts it into the hash table.
*
*----------------------------------------------------------------------
*/
Tcl_Channel
-Tcl_CreateChannel(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. */
+Tcl_CreateChannel(
+ Tcl_ChannelType *typePtr, /* The channel type record. */
+ const char *chanName, /* Name of channel to record. */
+ ClientData instanceData, /* Instance specific data. */
+ int mask) /* TCL_READABLE & TCL_WRITABLE to indicate if
+ * the channel is readable, writable. */
{
Channel *chanPtr; /* The channel structure newly created. */
- ChannelState *statePtr; /* The stack-level independent state info
- * for the channel. */
- CONST char *name;
+ ChannelState *statePtr; /* The stack-level independent state info for
+ * the channel. */
+ const char *name;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
/*
@@ -1143,59 +1238,67 @@ 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));
- statePtr = (ChannelState *) ckalloc((unsigned) sizeof(ChannelState));
+
+ chanPtr = (Channel *) ckalloc(sizeof(Channel));
+ statePtr = (ChannelState *) ckalloc(sizeof(ChannelState));
chanPtr->state = statePtr;
- chanPtr->instanceData = instanceData;
- chanPtr->typePtr = typePtr;
+ chanPtr->instanceData = instanceData;
+ chanPtr->typePtr = typePtr;
/*
* Set all the bits that are part of the stack-independent state
* information for the channel.
*/
- if (chanName != (char *) NULL) {
+ if (chanName != NULL) {
char *tmp = ckalloc((unsigned) (strlen(chanName) + 1));
- statePtr->channelName = tmp;
- strcpy(tmp, chanName);
+
+ statePtr->channelName = tmp;
+ strcpy(tmp, chanName);
} else {
- panic("Tcl_CreateChannel: NULL channel name");
+ Tcl_Panic("Tcl_CreateChannel: NULL channel name");
}
- statePtr->flags = mask;
+ statePtr->flags = mask;
/*
* Set the channel to system default encoding.
+ *
+ * Note the strange bit of protection taking place here. If the system
+ * encoding name is reported back as "binary", something weird is
+ * happening. Tcl provides no "binary" encoding, so someone else has
+ * provided one. We ignore it so as not to interfere with the "magic"
+ * interpretation that Tcl_Channels give to the "-encoding binary" option.
*/
statePtr->encoding = NULL;
name = Tcl_GetEncodingName(NULL);
if (strcmp(name, "binary") != 0) {
- statePtr->encoding = Tcl_GetEncoding(NULL, name);
+ statePtr->encoding = Tcl_GetEncoding(NULL, name);
}
- statePtr->inputEncodingState = NULL;
- statePtr->inputEncodingFlags = TCL_ENCODING_START;
- statePtr->outputEncodingState = NULL;
- statePtr->outputEncodingFlags = TCL_ENCODING_START;
+ statePtr->inputEncodingState = NULL;
+ statePtr->inputEncodingFlags = TCL_ENCODING_START;
+ statePtr->outputEncodingState = NULL;
+ statePtr->outputEncodingFlags = TCL_ENCODING_START;
/*
- * Set the channel up initially in AUTO input translation mode to
- * accept "\n", "\r" and "\r\n". Output translation mode is set to
- * a platform specific default value. The eofChar is set to 0 for both
- * input and output, so that Tcl does not look for an in-file EOF
- * indicator (e.g. ^Z) and does not append an EOF indicator to files.
+ * Set the channel up initially in AUTO input translation mode to accept
+ * "\n", "\r" and "\r\n". Output translation mode is set to a platform
+ * specific default value. The eofChar is set to 0 for both input and
+ * output, so that Tcl does not look for an in-file EOF indicator (e.g.
+ * ^Z) and does not append an EOF indicator to files.
*/
statePtr->inputTranslation = TCL_TRANSLATE_AUTO;
@@ -1205,16 +1308,16 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
statePtr->unreportedError = 0;
statePtr->refCount = 0;
- statePtr->closeCbPtr = (CloseCallback *) NULL;
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
- statePtr->outQueueHead = (ChannelBuffer *) NULL;
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
- statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
- statePtr->chPtr = (ChannelHandler *) NULL;
+ statePtr->closeCbPtr = NULL;
+ statePtr->curOutPtr = NULL;
+ statePtr->outQueueHead = NULL;
+ statePtr->outQueueTail = NULL;
+ statePtr->saveInBufPtr = NULL;
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
+ statePtr->chPtr = NULL;
statePtr->interestMask = 0;
- statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->scriptRecordPtr = NULL;
statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
statePtr->timer = NULL;
statePtr->csPtrR = NULL;
@@ -1223,58 +1326,64 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
statePtr->outputStage = NULL;
if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
statePtr->outputStage = (char *)
- ckalloc((unsigned) (statePtr->bufSize + 2));
+ ckalloc((unsigned) (statePtr->bufSize + 2));
}
/*
- * As we are creating the channel, it is obviously the top for now
+ * As we are creating the channel, it is obviously the top for now.
*/
+
statePtr->topChanPtr = chanPtr;
statePtr->bottomChanPtr = chanPtr;
- chanPtr->downChanPtr = (Channel *) NULL;
- chanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->inQueueHead = (ChannelBuffer*) NULL;
- chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ chanPtr->downChanPtr = NULL;
+ chanPtr->upChanPtr = NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
+
+ /*
+ * TIP #219, Tcl Channel Reflection API
+ */
+
+ statePtr->chanMsg = NULL;
+ statePtr->unreportedMsg = NULL;
/*
* Link the channel into the list of all channels; create an on-exit
- * handler if there is not one already, to close off all the channels
- * in the list on exit.
+ * handler if there is not one already, to close off all the channels in
+ * the list on exit.
*
* JH: Could call Tcl_SpliceChannel, but need to avoid NULL check.
*
* TIP #218.
* AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel
- * We need Tcl_SpliceChannel, for the threadAction calls.
- * There is no real reason to duplicate all of this.
+ * We need Tcl_SpliceChannel, for the threadAction calls. There is no
+ * real reason to duplicate all of this.
* NOTE: All drivers using thread actions now have to perform their TSD
- * manipulation only in their thread action proc. Doing it when
- * creating their instance structures will collide with the thread
- * action activity and lead to damaged lists.
+ * manipulation only in their thread action proc. Doing it when
+ * creating their instance structures will collide with the thread
+ * action activity and lead to damaged lists.
*/
- statePtr->nextCSPtr = (ChannelState *) NULL;
- Tcl_SpliceChannel ((Tcl_Channel) chanPtr);
+ statePtr->nextCSPtr = NULL;
+ 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 TCL_INHERIT_STD_CHANNELS
- 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);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
} else if ((tsdPtr->stdoutChannel == NULL) &&
(tsdPtr->stdoutInitialized == 1)) {
Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT);
- Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
} else if ((tsdPtr->stderrChannel == NULL) &&
(tsdPtr->stderrInitialized == 1)) {
Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR);
- Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
}
-#endif
return (Tcl_Channel) chanPtr;
}
@@ -1283,53 +1392,52 @@ 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.
*
*----------------------------------------------------------------------
*/
Tcl_Channel
-Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
- Tcl_Interp *interp; /* The interpreter we are working in */
- Tcl_ChannelType *typePtr; /* The channel type record for the new
- * channel. */
- ClientData instanceData; /* Instance specific data for the new
- * channel. */
- int mask; /* TCL_READABLE & TCL_WRITABLE to indicate
- * if the channel is readable, writable. */
- Tcl_Channel prevChan; /* The channel structure to replace */
-{
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- Channel *chanPtr, *prevChanPtr;
- ChannelState *statePtr;
-
- /*
- * Find the given channel in the list of all channels.
- * If we don't find it, then it was never registered correctly.
+Tcl_StackChannel(
+ Tcl_Interp *interp, /* The interpreter we are working in */
+ Tcl_ChannelType *typePtr, /* The channel type record for the new
+ * channel. */
+ ClientData instanceData, /* Instance specific data for the new
+ * channel. */
+ int mask, /* TCL_READABLE & TCL_WRITABLE to indicate if
+ * the channel is readable, writable. */
+ Tcl_Channel prevChan) /* The channel structure to replace */
+{
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ Channel *chanPtr, *prevChanPtr;
+ ChannelState *statePtr;
+ Tcl_DriverThreadActionProc *threadActionProc;
+
+ /*
+ * Find the given channel (prevChan) in the list of all channels. If we do
+ * not find it, then it was never registered correctly.
*
* This operation should occur at the top of a channel stack.
*/
- statePtr = (ChannelState *) tsdPtr->firstCSPtr;
+ statePtr = (ChannelState *) tsdPtr->firstCSPtr;
prevChanPtr = ((Channel *) prevChan)->state->topChanPtr;
while ((statePtr != NULL) && (statePtr->topChanPtr != prevChanPtr)) {
@@ -1339,21 +1447,21 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
if (statePtr == NULL) {
if (interp) {
Tcl_AppendResult(interp, "couldn't find state for channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
}
- return (Tcl_Channel) NULL;
+ return NULL;
}
/*
- * Here we check if the given "mask" matches the "flags"
- * of the already existing channel.
+ * Here we check if the given "mask" matches the "flags" of the already
+ * existing channel.
*
* | - | R | W | RW |
* --+---+---+---+----+ <=> 0 != (chan->mask & prevChan->mask)
* - | | | | |
- * R | | + | | + | The superceding channel is allowed to
- * 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| | + | + | + |
* --+---+---+---+----+
*/
@@ -1361,16 +1469,16 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
if (interp) {
Tcl_AppendResult(interp,
"reading and writing both disallowed for channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
}
- return (Tcl_Channel) NULL;
+ return NULL;
}
/*
- * Flush the buffers. This ensures that any data still in them
- * at this time is not handled by the new transformation. Restrict
- * this to writable channels. Take care to hide a possible bg-copy
- * in progress from Tcl_Flush and the CheckForChannelErrors inside.
+ * Flush the buffers. This ensures that any data still in them at this
+ * time is not handled by the new transformation. Restrict this to
+ * writable channels. Take care to hide a possible bg-copy in progress
+ * from Tcl_Flush and the CheckForChannelErrors inside.
*/
if ((mask & TCL_WRITABLE) != 0) {
@@ -1378,63 +1486,62 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
CopyState *csPtrW;
csPtrR = statePtr->csPtrR;
- statePtr->csPtrR = (CopyState*) NULL;
+ statePtr->csPtrR = NULL;
csPtrW = statePtr->csPtrW;
- statePtr->csPtrW = (CopyState*) NULL;
+ statePtr->csPtrW = NULL;
if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) {
- statePtr->csPtrR = csPtrR;
+ statePtr->csPtrR = csPtrR;
statePtr->csPtrW = csPtrW;
if (interp) {
Tcl_AppendResult(interp, "could not flush channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
}
- return (Tcl_Channel) NULL;
+ return NULL;
}
- statePtr->csPtrR = csPtrR;
+ statePtr->csPtrR = csPtrR;
statePtr->csPtrW = csPtrW;
}
+
/*
- * Discard any input in the buffers. They are not yet read by the
- * user of the channel, so they have to go through the new
- * transformation before reading. As the buffers contain the
- * untransformed form their contents are not only useless but actually
- * distorts our view of the system.
+ * Discard any input in the buffers. They are not yet read by the user of
+ * the channel, so they have to go through the new transformation before
+ * reading. As the buffers contain the untransformed form their contents
+ * are not only useless but actually distorts our view of the system.
*
- * To preserve the information without having to read them again and
- * to avoid problems with the location in the channel (seeking might
- * be impossible) we move the buffers from the common state structure
- * into the channel itself. We use the buffers in the channel below
- * the new transformation to hold the data. In the future this allows
- * us to write transformations which pre-read data and push the unused
- * part back when they are going away.
+ * To preserve the information without having to read them again and to
+ * avoid problems with the location in the channel (seeking might be
+ * impossible) we move the buffers from the common state structure into
+ * the channel itself. We use the buffers in the channel below the new
+ * transformation to hold the data. In the future this allows us to write
+ * transformations which pre-read data and push the unused part back when
+ * they are going away.
*/
- if (((mask & TCL_READABLE) != 0) &&
- (statePtr->inQueueHead != (ChannelBuffer*) NULL)) {
- /*
- * Remark: It is possible that the channel buffers contain data from
- * some earlier push-backs.
- */
+ if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) {
+ /*
+ * Remark: It is possible that the channel buffers contain data from
+ * some earlier push-backs.
+ */
- statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
- prevChanPtr->inQueueHead = statePtr->inQueueHead;
+ statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
+ prevChanPtr->inQueueHead = statePtr->inQueueHead;
- if (prevChanPtr->inQueueTail == (ChannelBuffer*) NULL) {
- prevChanPtr->inQueueTail = statePtr->inQueueTail;
- }
+ if (prevChanPtr->inQueueTail == NULL) {
+ prevChanPtr->inQueueTail = statePtr->inQueueTail;
+ }
- statePtr->inQueueHead = (ChannelBuffer*) NULL;
- statePtr->inQueueTail = (ChannelBuffer*) NULL;
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
}
- chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
+ chanPtr = (Channel *) ckalloc(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:
*/
@@ -1443,9 +1550,9 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
chanPtr->instanceData = instanceData;
chanPtr->typePtr = typePtr;
chanPtr->downChanPtr = prevChanPtr;
- chanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->inQueueHead = (ChannelBuffer*) NULL;
- chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ chanPtr->upChanPtr = NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
/*
* Place new block at the head of a possibly existing list of previously
@@ -1455,6 +1562,22 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
prevChanPtr->upChanPtr = chanPtr;
statePtr->topChanPtr = chanPtr;
+ /*
+ * TIP #218, Channel Thread Actions.
+ *
+ * We call the thread actions for the new channel directly. We _cannot_
+ * use SpliceChannel, because the (thread-)global list of all channels
+ * always contains the _ChannelState_ for a stack of channels, not the
+ * individual channels. And SpliceChannel would not only call the thread
+ * actions, but also add the shared ChannelState to this list a second
+ * time, mangling it.
+ */
+
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
+ if (threadActionProc != NULL) {
+ (*threadActionProc)(chanPtr->instanceData, TCL_CHANNEL_THREAD_INSERT);
+ }
+
return (Tcl_Channel) chanPtr;
}
@@ -1463,27 +1586,28 @@ 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. May leave a message in interp result as well.
*
*----------------------------------------------------------------------
*/
int
-Tcl_UnstackChannel (interp, chan)
- Tcl_Interp *interp; /* The interpreter we are working in */
- Tcl_Channel chan; /* The channel to unstack */
+Tcl_UnstackChannel(
+ Tcl_Interp *interp, /* The interpreter we are working in */
+ Tcl_Channel chan) /* The channel to unstack */
{
- Channel *chanPtr = (Channel *) chan;
+ Channel *chanPtr = (Channel *) chan;
ChannelState *statePtr = chanPtr->state;
int result = 0;
+ Tcl_DriverThreadActionProc *threadActionProc;
/*
* This operation should occur at the top of a channel stack.
@@ -1491,20 +1615,21 @@ Tcl_UnstackChannel (interp, chan)
chanPtr = statePtr->topChanPtr;
- if (chanPtr->downChanPtr != (Channel *) NULL) {
- /*
+ if (chanPtr->downChanPtr != NULL) {
+ /*
* Instead of manipulating the per-thread / per-interp list/hashtable
* of registered channels we wind down the state of the transformation,
* and then restore the state of underlying channel into the old
* structure.
*/
+
Channel *downChanPtr = chanPtr->downChanPtr;
/*
- * 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.
*/
@@ -1513,18 +1638,27 @@ Tcl_UnstackChannel (interp, chan)
CopyState *csPtrW;
csPtrR = statePtr->csPtrR;
- statePtr->csPtrR = (CopyState*) NULL;
+ statePtr->csPtrR = NULL;
csPtrW = statePtr->csPtrW;
- statePtr->csPtrW = (CopyState*) NULL;
+ statePtr->csPtrW = NULL;
if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
- statePtr->csPtrR = csPtrR;
+ statePtr->csPtrR = csPtrR;
statePtr->csPtrW = csPtrW;
- if (interp) {
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move error messages put by the driver into the chan/ip
+ * bypass area into the regular interpreter result. Fall back
+ * to the regular message if nothing was found in the
+ * bypasses.
+ */
+
+ if (!TclChanCaughtErrorBypass(interp, chan) && interp) {
Tcl_AppendResult(interp, "could not flush channel \"",
Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
- (char *) NULL);
+ NULL);
}
return TCL_ERROR;
}
@@ -1534,42 +1668,60 @@ 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) &&
- ((statePtr->inQueueHead != (ChannelBuffer*) NULL) ||
- (chanPtr->inQueueHead != (ChannelBuffer*) NULL))) {
+ if ((((statePtr->flags & TCL_READABLE) != 0)) &&
+ ((statePtr->inQueueHead != NULL) ||
+ (chanPtr->inQueueHead != NULL))) {
- if ((statePtr->inQueueHead != (ChannelBuffer*) NULL) &&
- (chanPtr->inQueueHead != (ChannelBuffer*) NULL)) {
- statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
+ if ((statePtr->inQueueHead != NULL) &&
+ (chanPtr->inQueueHead != NULL)) {
+ statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
- statePtr->inQueueHead = statePtr->inQueueTail;
+ statePtr->inQueueHead = statePtr->inQueueTail;
- } else if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
- statePtr->inQueueHead = chanPtr->inQueueHead;
+ } else if (chanPtr->inQueueHead != NULL) {
+ statePtr->inQueueHead = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
}
- chanPtr->inQueueHead = (ChannelBuffer*) NULL;
- chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
- DiscardInputQueued (statePtr, 0);
+ DiscardInputQueued(statePtr, 0);
}
- statePtr->topChanPtr = downChanPtr;
- downChanPtr->upChanPtr = (Channel *) NULL;
+ /*
+ * TIP #218, Channel Thread Actions.
+ *
+ * We call the thread actions for the new channel directly. We
+ * _cannot_ use CutChannel, because the (thread-)global list of all
+ * channels always contains the _ChannelState_ for a stack of
+ * channels, not the individual channels. And SpliceChannel would not
+ * only call the thread actions, but also remove the shared
+ * ChannelState from this list despite there being more channels for
+ * the state which are still active.
+ */
+
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
+ if (threadActionProc != NULL) {
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_REMOVE);
+ }
+
+ statePtr->topChanPtr = downChanPtr;
+ downChanPtr->upChanPtr = NULL;
/*
* Leave this link intact for closeproc
- * chanPtr->downChanPtr = (Channel *) NULL;
+ * chanPtr->downChanPtr = NULL;
*/
/*
@@ -1584,28 +1736,51 @@ Tcl_UnstackChannel (interp, chan)
interp, 0);
}
- chanPtr->typePtr = NULL;
+ chanPtr->typePtr = NULL;
+
/*
* AK: Tcl_NotifyChannel may hold a reference to this block of memory
*/
- Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+
+ Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC);
UpdateInterest(downChanPtr);
if (result != 0) {
Tcl_SetErrno(result);
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move error messages put by the driver into the chan/ip bypass
+ * area into the regular interpreter result.
+ */
+
+ TclChanCaughtErrorBypass(interp, chan);
return TCL_ERROR;
}
} else {
- /*
- * This channel does not cover another one.
- * Simply do a close, if necessary.
+ /*
+ * This channel does not cover another one. Simply do a close, if
+ * necessary.
*/
- if (statePtr->refCount <= 0) {
- if (Tcl_Close(interp, chan) != TCL_OK) {
- return TCL_ERROR;
- }
+ if (statePtr->refCount <= 0) {
+ if (Tcl_Close(interp, chan) != TCL_OK) {
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * "TclChanCaughtErrorBypass" is not required here, it was
+ * done already by "Tcl_Close".
+ */
+
+ return TCL_ERROR;
+ }
}
+
+ /*
+ * TIP #218, Channel Thread Actions.
+ * Not required in this branch, this is done by Tcl_Close. If
+ * Tcl_Close is not called then the ChannelState is still active in
+ * the thread and no action has to be taken either.
+ */
}
return TCL_OK;
@@ -1619,9 +1794,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.
@@ -1630,10 +1805,11 @@ Tcl_UnstackChannel (interp, chan)
*/
Tcl_Channel
-Tcl_GetStackedChannel(chan)
- Tcl_Channel chan;
+Tcl_GetStackedChannel(
+ Tcl_Channel chan)
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return (Tcl_Channel) chanPtr->downChanPtr;
}
@@ -1646,9 +1822,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.
@@ -1657,10 +1833,11 @@ Tcl_GetStackedChannel(chan)
*/
Tcl_Channel
-Tcl_GetTopChannel(chan)
- Tcl_Channel chan;
+Tcl_GetTopChannel(
+ Tcl_Channel chan)
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return (Tcl_Channel) chanPtr->state->topChanPtr;
}
@@ -1682,10 +1859,11 @@ Tcl_GetTopChannel(chan)
*/
ClientData
-Tcl_GetChannelInstanceData(chan)
- Tcl_Channel chan; /* Channel for which to return client data. */
+Tcl_GetChannelInstanceData(
+ Tcl_Channel chan) /* Channel for which to return client data. */
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return chanPtr->instanceData;
}
@@ -1695,8 +1873,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.
@@ -1708,10 +1885,12 @@ Tcl_GetChannelInstanceData(chan)
*/
Tcl_ThreadId
-Tcl_GetChannelThread(chan)
- Tcl_Channel chan; /* The channel to return managing thread for. */
+Tcl_GetChannelThread(
+ Tcl_Channel chan) /* The channel to return the managing thread
+ * for. */
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return chanPtr->state->managingThread;
}
@@ -1733,10 +1912,11 @@ Tcl_GetChannelThread(chan)
*/
Tcl_ChannelType *
-Tcl_GetChannelType(chan)
- Tcl_Channel chan; /* The channel to return type for. */
+Tcl_GetChannelType(
+ 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;
}
@@ -1746,8 +1926,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.
@@ -1759,12 +1939,12 @@ Tcl_GetChannelType(chan)
*/
int
-Tcl_GetChannelMode(chan)
- Tcl_Channel chan; /* The channel for which the mode is
- * being computed. */
+Tcl_GetChannelMode(
+ 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));
}
@@ -1777,9 +1957,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.
@@ -1787,9 +1966,9 @@ Tcl_GetChannelMode(chan)
*----------------------------------------------------------------------
*/
-CONST char *
-Tcl_GetChannelName(chan)
- Tcl_Channel chan; /* The channel for which to return the name. */
+const char *
+Tcl_GetChannelName(
+ Tcl_Channel chan) /* The channel for which to return the name. */
{
ChannelState *statePtr; /* State of actual channel. */
@@ -1815,16 +1994,24 @@ Tcl_GetChannelName(chan)
*/
int
-Tcl_GetChannelHandle(chan, direction, handlePtr)
- Tcl_Channel chan; /* The channel to get file from. */
- int direction; /* TCL_WRITABLE or TCL_READABLE. */
- ClientData *handlePtr; /* Where to store handle */
+Tcl_GetChannelHandle(
+ Tcl_Channel chan, /* The channel to get file from. */
+ int direction, /* TCL_WRITABLE or TCL_READABLE. */
+ ClientData *handlePtr) /* Where to store handle */
{
Channel *chanPtr; /* The actual channel. */
ClientData handle;
int result;
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ if (!chanPtr->typePtr->getHandleProc) {
+ Tcl_Obj* err;
+ TclNewLiteralStringObj(err, "channel \"");
+ Tcl_AppendToObj(err, Tcl_GetChannelName(chan), -1);
+ Tcl_AppendToObj(err, "\" does not support OS handles", -1);
+ Tcl_SetChannelError (chan,err);
+ return TCL_ERROR;
+ }
result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
direction, &handle);
if (handlePtr) {
@@ -1838,16 +2025,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.
@@ -1859,8 +2045,8 @@ Tcl_GetChannelHandle(chan, direction, handlePtr)
*/
static ChannelBuffer *
-AllocChannelBuffer(length)
- int length; /* Desired length of channel buffer. */
+AllocChannelBuffer(
+ int length) /* Desired length of channel buffer. */
{
ChannelBuffer *bufPtr;
int n;
@@ -1870,7 +2056,7 @@ AllocChannelBuffer(length)
bufPtr->nextAdded = BUFFER_PADDING;
bufPtr->nextRemoved = BUFFER_PADDING;
bufPtr->bufLength = length + BUFFER_PADDING;
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
return bufPtr;
}
@@ -1879,11 +2065,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.
@@ -1895,46 +2080,46 @@ AllocChannelBuffer(length)
*/
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. */
+RecycleBuffer(
+ ChannelState *statePtr, /* ChannelState in which to recycle buffers. */
+ ChannelBuffer *bufPtr, /* The buffer to recycle. */
+ int mustDiscard) /* If nonzero, free the buffer to the OS,
+ * always. */
{
/*
* Do we have to free the buffer to the OS?
*/
if (mustDiscard) {
- ckfree((char *) bufPtr);
- return;
+ ckfree((char *) bufPtr);
+ return;
}
/*
- * Only save buffers which are at least as big as the requested
- * buffersize for the channel. This is to honor dynamic changes
- * of the buffersize made by the user.
+ * Only save buffers which are at least as big as the requested buffersize
+ * for the channel. This is to honor dynamic changes of the buffersize
+ * made by the user.
*/
if ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize) {
- ckfree((char *) bufPtr);
- return;
+ ckfree((char *) bufPtr);
+ return;
}
/*
* Only save buffers for the input queue if the channel is readable.
*/
-
+
if (statePtr->flags & TCL_READABLE) {
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- statePtr->inQueueHead = bufPtr;
- statePtr->inQueueTail = bufPtr;
- goto keepit;
- }
- if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) {
- statePtr->saveInBufPtr = bufPtr;
- goto keepit;
- }
+ if (statePtr->inQueueHead == NULL) {
+ statePtr->inQueueHead = bufPtr;
+ statePtr->inQueueTail = bufPtr;
+ goto keepBuffer;
+ }
+ if (statePtr->saveInBufPtr == NULL) {
+ statePtr->saveInBufPtr = bufPtr;
+ goto keepBuffer;
+ }
}
/*
@@ -1942,10 +2127,10 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
*/
if (statePtr->flags & TCL_WRITABLE) {
- if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
- statePtr->curOutPtr = bufPtr;
- goto keepit;
- }
+ if (statePtr->curOutPtr == NULL) {
+ statePtr->curOutPtr = bufPtr;
+ goto keepBuffer;
+ }
}
/*
@@ -1955,10 +2140,10 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
ckfree((char *) bufPtr);
return;
- keepit:
+ keepBuffer:
bufPtr->nextRemoved = BUFFER_PADDING;
bufPtr->nextAdded = BUFFER_PADDING;
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
}
/*
@@ -1978,18 +2163,18 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
*/
static void
-DiscardOutputQueued(statePtr)
- ChannelState *statePtr; /* ChannelState for which to discard output. */
+DiscardOutputQueued(
+ ChannelState *statePtr) /* ChannelState for which to discard output. */
{
ChannelBuffer *bufPtr;
-
- while (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
- bufPtr = statePtr->outQueueHead;
- statePtr->outQueueHead = bufPtr->nextPtr;
- RecycleBuffer(statePtr, bufPtr, 0);
+
+ while (statePtr->outQueueHead != NULL) {
+ bufPtr = statePtr->outQueueHead;
+ statePtr->outQueueHead = bufPtr->nextPtr;
+ RecycleBuffer(statePtr, bufPtr, 0);
}
- statePtr->outQueueHead = (ChannelBuffer *) NULL;
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
+ statePtr->outQueueHead = NULL;
+ statePtr->outQueueTail = NULL;
}
/*
@@ -1997,29 +2182,28 @@ 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
*
* Side effects:
- * None
+ * None
*
*----------------------------------------------------------------------
*/
static int
-CheckForDeadChannel(interp, statePtr)
- Tcl_Interp *interp; /* For error reporting (can be NULL) */
- ChannelState *statePtr; /* The channel state to check. */
+CheckForDeadChannel(
+ Tcl_Interp *interp, /* For error reporting (can be NULL) */
+ ChannelState *statePtr) /* The channel state to check. */
{
if (statePtr->flags & CHANNEL_DEAD) {
- Tcl_SetErrno(EINVAL);
+ Tcl_SetErrno(EINVAL);
if (interp) {
Tcl_AppendResult(interp,
- "unable to access channel: invalid channel",
- (char *) NULL);
+ "unable to access channel: invalid channel", NULL);
}
return 1;
}
@@ -2036,221 +2220,253 @@ 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. May leave a message in the interp result.
*
* Side effects:
- * May produce output on a channel. May block indefinitely if the
- * channel is synchronous. May schedule an async flush on the channel.
- * May recycle memory for buffers in the output queue.
+ * May produce output on a channel. May block indefinitely if the channel
+ * is synchronous. May schedule an async flush on the channel. May
+ * recycle memory for buffers in the output queue.
*
*----------------------------------------------------------------------
*/
static int
-FlushChannel(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. */
+FlushChannel(
+ Tcl_Interp *interp, /* For error reporting during close. */
+ Channel *chanPtr, /* The channel to flush on. */
+ int calledFromAsyncFlush) /* If nonzero then we are being called from an
+ * asynchronous flush callback. */
{
ChannelState *statePtr = chanPtr->state;
- /* State of the channel stack. */
- ChannelBuffer *bufPtr; /* Iterates over buffered output
- * queue. */
- int toWrite; /* Amount of output data in current
- * buffer available to be written. */
- int written; /* Amount of output data actually
- * written in current round. */
- int errorCode = 0; /* Stores POSIX error codes from
- * channel driver operations. */
- int wroteSome = 0; /* Set to one if any data was
- * written to the driver. */
+ /* State of the channel stack. */
+ ChannelBuffer *bufPtr; /* Iterates over buffered output queue. */
+ int toWrite; /* Amount of output data in current buffer
+ * available to be written. */
+ int written; /* Amount of output data actually written in
+ * current round. */
+ int errorCode = 0; /* Stores POSIX error codes from channel
+ * driver operations. */
+ int wroteSome = 0; /* Set to one if any data was written to the
+ * driver. */
/*
- * Prevent writing on a dead channel -- a channel that has been closed
- * but not yet deallocated. This can occur if the exit handler for the
- * channel deallocation runs before all channels are deregistered in
- * all interpreters.
+ * Prevent writing on a dead channel -- a channel that has been closed but
+ * not yet deallocated. This can occur if the exit handler for the channel
+ * deallocation runs before all channels are deregistered in all
+ * interpreters.
*/
-
- if (CheckForDeadChannel(interp, statePtr)) return -1;
-
+
+ if (CheckForDeadChannel(interp, statePtr)) {
+ return -1;
+ }
+
/*
- * Loop over the queued buffers and attempt to flush as
- * much as possible of the queued output to the channel.
+ * Loop over the queued buffers and attempt to flush as much as possible
+ * of the queued output to the channel.
*/
while (1) {
+ /*
+ * If the queue is empty and there is a ready current buffer, OR if
+ * the current buffer is full, then move the current buffer to the
+ * queue.
+ */
+
+ if (((statePtr->curOutPtr != NULL) &&
+ IsBufferFull(statePtr->curOutPtr))
+ || ((statePtr->flags & BUFFER_READY) &&
+ (statePtr->outQueueHead == NULL))) {
+ ResetFlag(statePtr, BUFFER_READY);
+ statePtr->curOutPtr->nextPtr = NULL;
+ if (statePtr->outQueueHead == NULL) {
+ statePtr->outQueueHead = statePtr->curOutPtr;
+ } else {
+ statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
+ }
+ statePtr->outQueueTail = statePtr->curOutPtr;
+ statePtr->curOutPtr = NULL;
+ }
+ bufPtr = statePtr->outQueueHead;
- /*
- * If the queue is empty and there is a ready current buffer, OR if
- * the current buffer is full, then move the current buffer to the
- * queue.
- */
-
- if (((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
- || ((statePtr->flags & BUFFER_READY) &&
- (statePtr->outQueueHead == (ChannelBuffer *) NULL))) {
- statePtr->flags &= (~(BUFFER_READY));
- statePtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
- if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
- statePtr->outQueueHead = statePtr->curOutPtr;
- } else {
- statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
- }
- statePtr->outQueueTail = statePtr->curOutPtr;
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
- }
- bufPtr = statePtr->outQueueHead;
-
- /*
- * If we are not being called from an async flush and an async
- * flush is active, we just return without producing any output.
- */
-
- if ((!calledFromAsyncFlush) &&
- (statePtr->flags & BG_FLUSH_SCHEDULED)) {
- return 0;
- }
-
- /*
- * If the output queue is still empty, break out of the while loop.
- */
-
- if (bufPtr == (ChannelBuffer *) NULL) {
- break; /* Out of the "while (1)". */
- }
-
- /*
- * Produce the output on the channel.
- */
-
- toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
+ /*
+ * If we are not being called from an async flush and an async flush
+ * is active, we just return without producing any output.
+ */
+
+ if ((!calledFromAsyncFlush) &&
+ (statePtr->flags & BG_FLUSH_SCHEDULED)) {
+ return 0;
+ }
+
+ /*
+ * If the output queue is still empty, break out of the while loop.
+ */
+
+ if (bufPtr == NULL) {
+ break; /* Out of the "while (1)". */
+ }
+
+ /*
+ * Produce the output on the channel.
+ */
+
+ toWrite = BytesLeft(bufPtr);
if (toWrite == 0) {
written = 0;
} else {
- written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
- bufPtr->buf + bufPtr->nextRemoved, toWrite,
- &errorCode);
+ written = (chanPtr->typePtr->outputProc)(chanPtr->instanceData,
+ RemovePoint(bufPtr), toWrite, &errorCode);
}
/*
- * If the write failed completely attempt to start the asynchronous
- * flush mechanism and break out of this loop - do not attempt to
- * write any more output at this time.
- */
-
- if (written < 0) {
-
- /*
- * If the last attempt to write was interrupted, simply retry.
- */
-
- if (errorCode == EINTR) {
- errorCode = 0;
- continue;
- }
-
- /*
- * If the channel is non-blocking and we would have blocked,
- * start a background flushing handler and break out of the loop.
- */
-
- if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
+ * If the write failed completely attempt to start the asynchronous
+ * flush mechanism and break out of this loop - do not attempt to
+ * write any more output at this time.
+ */
+
+ if (written < 0) {
+ /*
+ * If the last attempt to write was interrupted, simply retry.
+ */
+
+ if (errorCode == EINTR) {
+ errorCode = 0;
+ continue;
+ }
+
+ /*
+ * If the channel is non-blocking and we would have blocked, start
+ * a background flushing handler and break out of the loop.
+ */
+
+ if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
/*
- * This used to check for CHANNEL_NONBLOCKING, and panic
- * if the channel was blocking. However, it appears
- * 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)) {
- statePtr->flags |= BG_FLUSH_SCHEDULED;
+ SetFlag(statePtr, BG_FLUSH_SCHEDULED);
UpdateInterest(chanPtr);
}
errorCode = 0;
break;
- }
+ }
- /*
- * Decide whether to report the error upwards or defer it.
- */
+ /*
+ * Decide whether to report the error upwards or defer it.
+ */
+
+ if (calledFromAsyncFlush) {
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * When defering the error copy a message from the bypass into
+ * the unreported area. Or discard it if the new error is to be
+ * ignored in favor of an earlier defered error.
+ */
+
+ Tcl_Obj *msg = statePtr->chanMsg;
+
+ if (statePtr->unreportedError == 0) {
+ statePtr->unreportedError = errorCode;
+ statePtr->unreportedMsg = msg;
+ if (msg != NULL) {
+ Tcl_IncrRefCount(msg);
+ }
+ } else {
+ /*
+ * An old unreported error is kept, and this error thrown
+ * away.
+ */
- if (calledFromAsyncFlush) {
- if (statePtr->unreportedError == 0) {
- statePtr->unreportedError = errorCode;
- }
- } else {
- Tcl_SetErrno(errorCode);
- if (interp != NULL) {
+ statePtr->chanMsg = NULL;
+ if (msg != NULL) {
+ TclDecrRefCount(msg);
+ }
+ }
+ } else {
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move error messages put by the driver into the chan bypass
+ * area into the regular interpreter result. Fall back to the
+ * regular message if nothing was found in the bypasses.
+ */
+ Tcl_SetErrno(errorCode);
+ if (interp != NULL && !TclChanCaughtErrorBypass(interp,
+ (Tcl_Channel) chanPtr)) {
/*
- * Casting away CONST here is safe because the
- * TCL_VOLATILE flag guarantees CONST treatment
- * of the Posix error string.
+ * Casting away const here is safe because the
+ * TCL_VOLATILE flag guarantees const treatment of the
+ * Posix error string.
*/
- Tcl_SetResult(interp,
- (char *) Tcl_PosixError(interp), TCL_VOLATILE);
+ Tcl_SetResult(interp, (char *) Tcl_PosixError(interp),
+ TCL_VOLATILE);
}
- }
- /*
- * When we get an error we throw away all the output
- * currently queued.
- */
+ /*
+ * An unreportable bypassed message is kept, for the caller of
+ * Tcl_Seek, Tcl_Write, etc.
+ */
+ }
+
+ /*
+ * When we get an error we throw away all the output currently
+ * queued.
+ */
- DiscardOutputQueued(statePtr);
- continue;
- } else {
+ DiscardOutputQueued(statePtr);
+ continue;
+ } else {
wroteSome = 1;
}
- bufPtr->nextRemoved += written;
+ bufPtr->nextRemoved += written;
- /*
- * If this buffer is now empty, recycle it.
- */
+ /*
+ * If this buffer is now empty, recycle it.
+ */
- if (bufPtr->nextRemoved == bufPtr->nextAdded) {
- statePtr->outQueueHead = bufPtr->nextPtr;
- if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
- }
- RecycleBuffer(statePtr, bufPtr, 0);
- }
+ if (IsBufferEmpty(bufPtr)) {
+ statePtr->outQueueHead = bufPtr->nextPtr;
+ if (statePtr->outQueueHead == NULL) {
+ statePtr->outQueueTail = NULL;
+ }
+ RecycleBuffer(statePtr, bufPtr, 0);
+ }
} /* Closes "while (1)". */
/*
* If we wrote some data while flushing in the background, we are done.
- * We can't finish the background flush until we run out of data and
- * the channel becomes writable again. This ensures that all of the
- * pending data has been flushed at the system level.
+ * We can't finish the background flush until we run out of data and the
+ * channel becomes writable again. This ensures that all of the pending
+ * data has been flushed at the system level.
*/
if (statePtr->flags & BG_FLUSH_SCHEDULED) {
if (wroteSome) {
return errorCode;
- } else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
- statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
+ } else if (statePtr->outQueueHead == NULL) {
+ ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
statePtr->interestMask);
}
}
/*
- * If the channel is flagged as closed, delete it when the refCount
- * drops to zero, the output queue is empty and there is no output
- * in the current output buffer.
+ * If the channel is flagged as closed, delete it when the refCount drops
+ * to zero, the output queue is empty and there is no output in the
+ * current output buffer.
*/
if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
- (statePtr->outQueueHead == (ChannelBuffer *) NULL) &&
- ((statePtr->curOutPtr == (ChannelBuffer *) NULL) ||
- (statePtr->curOutPtr->nextAdded ==
- statePtr->curOutPtr->nextRemoved))) {
+ (statePtr->outQueueHead == NULL) &&
+ ((statePtr->curOutPtr == NULL) ||
+ IsBufferEmpty(statePtr->curOutPtr))) {
return CloseChannel(interp, chanPtr, errorCode);
}
return errorCode;
@@ -2265,34 +2481,33 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*
* If the channel was stacked, then the it will copy the necessary
* elements of the NEXT channel into the TOP channel, in essence
- * unstacking the channel. The NEXT channel will then be freed.
+ * unstacking the channel. The NEXT channel will then be freed.
*
- * If the channel was not stacked, then we will free all the bits
- * for the TOP channel, including the data structure itself.
+ * If the channel was not stacked, then we will free all the bits for the
+ * TOP channel, including the data structure itself.
*
* Results:
- * 1 if the channel was stacked, 0 otherwise.
+ * Error code from an unreported error or the driver close operation.
*
* Side effects:
- * May close the actual channel; may free memory.
- * May change the value of errno.
+ * May close the actual channel, may free memory, may change the value of
+ * errno.
*
*----------------------------------------------------------------------
*/
static int
-CloseChannel(interp, chanPtr, errorCode)
- Tcl_Interp *interp; /* For error reporting. */
- Channel *chanPtr; /* The channel to close. */
- int errorCode; /* Status of operation so far. */
-{
- int result = 0; /* Of calling driver close
- * operation. */
- ChannelState *statePtr; /* state of the channel stack. */
+CloseChannel(
+ Tcl_Interp *interp, /* For error reporting. */
+ Channel *chanPtr, /* The channel to close. */
+ int errorCode) /* Status of operation so far. */
+{
+ int result = 0; /* Of calling driver close operation. */
+ ChannelState *statePtr; /* State of the channel stack. */
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if (chanPtr == NULL) {
- return result;
+ return result;
}
statePtr = chanPtr->state;
@@ -2306,57 +2521,70 @@ CloseChannel(interp, chanPtr, errorCode)
* Discard a leftover buffer in the current output buffer field.
*/
- if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
- ckfree((char *) statePtr->curOutPtr);
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
+ if (statePtr->curOutPtr != NULL) {
+ ckfree((char *) statePtr->curOutPtr);
+ statePtr->curOutPtr = NULL;
}
-
+
/*
- * The caller guarantees that there are no more buffers
- * queued for output.
+ * The caller guarantees that there are no more buffers queued for output.
*/
- if (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
- panic("TclFlush, closed channel: queued output left");
+ if (statePtr->outQueueHead != NULL) {
+ Tcl_Panic("TclFlush, closed channel: queued output left");
}
/*
- * If the EOF character is set in the channel, append that to the
- * output device.
+ * If the EOF character is set in the channel, append that to the output
+ * device.
*/
if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) {
- int dummy;
- char c;
+ int dummy;
+ char c = (char) statePtr->outEofChar;
- c = (char) statePtr->outEofChar;
- (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
+ (chanPtr->typePtr->outputProc)(chanPtr->instanceData, &c, 1, &dummy);
+ }
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move a leftover error message in the channel bypass into the
+ * interpreter bypass. Just clear it if there is no interpreter.
+ */
+
+ if (statePtr->chanMsg != NULL) {
+ if (interp != NULL) {
+ Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
+ }
+ TclDecrRefCount(statePtr->chanMsg);
+ statePtr->chanMsg = NULL;
}
/*
* Remove this channel from of the list of all channels.
*/
- Tcl_CutChannel((Tcl_Channel) chanPtr);
+
+ CutChannel((Tcl_Channel) chanPtr);
/*
* Close and free the channel driver state.
+ * This may leave a TIP #219 error message in the interp.
*/
if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp);
} else {
- result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
- 0);
+ result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
+ interp, 0);
}
/*
- * Some resources can be cleared only if the bottom channel
- * in a stack is closed. All the other channels in the stack
- * are not allowed to remove.
+ * Some resources can be cleared only if the bottom channel in a stack is
+ * closed. All the other channels in the stack are not allowed to remove.
*/
if (chanPtr == statePtr->bottomChanPtr) {
- if (statePtr->channelName != (char *) NULL) {
+ if (statePtr->channelName != NULL) {
ckfree((char *) statePtr->channelName);
statePtr->channelName = NULL;
}
@@ -2364,23 +2592,37 @@ CloseChannel(interp, chanPtr, errorCode)
Tcl_FreeEncoding(statePtr->encoding);
if (statePtr->outputStage != NULL) {
ckfree((char *) statePtr->outputStage);
- statePtr->outputStage = (char *) NULL;
+ statePtr->outputStage = NULL;
}
}
/*
- * If we are being called synchronously, report either
- * any latent error on the channel or the current error.
+ * If we are being called synchronously, report either any latent error on
+ * the channel or the current error.
*/
if (statePtr->unreportedError != 0) {
- errorCode = statePtr->unreportedError;
+ errorCode = statePtr->unreportedError;
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move an error message found in the unreported area into the regular
+ * bypass (interp). This kills any message in the channel bypass area.
+ */
+
+ if (statePtr->chanMsg != NULL) {
+ TclDecrRefCount(statePtr->chanMsg);
+ statePtr->chanMsg = NULL;
+ }
+ if (interp) {
+ Tcl_SetChannelErrorInterp(interp,statePtr->unreportedMsg);
+ }
}
if (errorCode == 0) {
- errorCode = result;
- if (errorCode != 0) {
- Tcl_SetErrno(errorCode);
- }
+ errorCode = result;
+ if (errorCode != 0) {
+ Tcl_SetErrno(errorCode);
+ }
}
/*
@@ -2393,31 +2635,31 @@ CloseChannel(interp, chanPtr, errorCode)
* Mark the channel as deleted by clearing the type structure.
*/
- if (chanPtr->downChanPtr != (Channel *) NULL) {
+ if (chanPtr->downChanPtr != NULL) {
Channel *downChanPtr = chanPtr->downChanPtr;
- statePtr->nextCSPtr = tsdPtr->firstCSPtr;
- tsdPtr->firstCSPtr = statePtr;
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
- statePtr->topChanPtr = downChanPtr;
- downChanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->typePtr = NULL;
+ statePtr->topChanPtr = downChanPtr;
+ downChanPtr->upChanPtr = NULL;
+ chanPtr->typePtr = NULL;
- Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+ Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC);
return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
}
/*
- * There is only the TOP Channel, so we free the remaining
- * pointers we have and then ourselves. Since this is the
- * last of the channels in the stack, make sure to free the
- * ChannelState structure associated with it. We use
- * Tcl_EventuallyFree to allow for any last
+ * There is only the TOP Channel, so we free the remaining pointers we
+ * have and then ourselves. Since this is the last of the channels in the
+ * stack, make sure to free the ChannelState structure associated with it.
+ * We use Tcl_EventuallyFree to allow for any last references.
*/
+
chanPtr->typePtr = NULL;
- Tcl_EventuallyFree((ClientData) statePtr, TCL_DYNAMIC);
- Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+ Tcl_EventuallyFree(statePtr, TCL_DYNAMIC);
+ Tcl_EventuallyFree(chanPtr, TCL_DYNAMIC);
return errorCode;
}
@@ -2426,10 +2668,10 @@ CloseChannel(interp, chanPtr, errorCode)
*----------------------------------------------------------------------
*
* Tcl_CutChannel --
+ * CutChannel --
*
- * Removes a channel from the (thread-)global list of all channels
- * (in that thread). This is actually the statePtr for the stack
- * of channel.
+ * Removes a channel from the (thread-)global list of all channels (in
+ * that thread). This is actually the statePtr for the stack of channel.
*
* Results:
* Nothing.
@@ -2438,56 +2680,107 @@ 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.
*
*----------------------------------------------------------------------
*/
-void
-Tcl_CutChannel(chan)
- Tcl_Channel chan; /* The channel being removed. Must
- * not be referenced in any
- * interpreter. */
-{
- ThreadSpecificData* tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *prevCSPtr; /* Preceding channel state in list of
- * all states - used to splice a
- * channel out of the list on close. */
+static void
+CutChannel(
+ Tcl_Channel chan) /* The channel being removed. Must not be
+ * referenced in any interpreter. */
+{
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *prevCSPtr; /* Preceding channel state in list of all
+ * states - used to splice a channel out of
+ * the list on close. */
ChannelState *statePtr = ((Channel *) chan)->state;
- /* state of the channel stack. */
+ /* State of the channel stack. */
Tcl_DriverThreadActionProc *threadActionProc;
/*
- * Remove this channel from of the list of all channels
- * (in the current thread).
+ * Remove this channel from of the list of all channels (in the current
+ * thread).
*/
if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
- tsdPtr->firstCSPtr = statePtr->nextCSPtr;
+ tsdPtr->firstCSPtr = statePtr->nextCSPtr;
} else {
- for (prevCSPtr = tsdPtr->firstCSPtr;
- prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
- prevCSPtr = prevCSPtr->nextCSPtr) {
- /* Empty loop body. */
- }
- if (prevCSPtr == (ChannelState *) NULL) {
- panic("FlushChannel: damaged channel list");
- }
- prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
+ for (prevCSPtr = tsdPtr->firstCSPtr;
+ prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+ prevCSPtr = prevCSPtr->nextCSPtr) {
+ /* Empty loop body. */
+ }
+ if (prevCSPtr == NULL) {
+ Tcl_Panic("FlushChannel: damaged channel list");
+ }
+ prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
}
- statePtr->nextCSPtr = (ChannelState *) NULL;
+ statePtr->nextCSPtr = NULL;
- /* TIP #218, Channel Thread Actions */
- threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan));
+ /*
+ * TIP #218, Channel Thread Actions
+ */
+
+ 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);
+ }
+}
+
+void
+Tcl_CutChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
+{
+ Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *prevCSPtr; /* Preceding channel state in list of all
+ * states - used to splice a channel out of
+ * the list on close. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State of the channel stack. */
+ Tcl_DriverThreadActionProc *threadActionProc;
+
+ /*
+ * Remove this channel from of the list of all channels (in the current
+ * thread).
+ */
+
+ if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
+ tsdPtr->firstCSPtr = statePtr->nextCSPtr;
+ } else {
+ for (prevCSPtr = tsdPtr->firstCSPtr;
+ prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+ prevCSPtr = prevCSPtr->nextCSPtr) {
+ /* Empty loop body. */
+ }
+ if (prevCSPtr == NULL) {
+ Tcl_Panic("FlushChannel: damaged channel list");
+ }
+ prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
+ }
+
+ statePtr->nextCSPtr = NULL;
+
+ /*
+ * TIP #218, Channel Thread Actions
+ * For all transformations and the base channel.
+ */
+
+ while (chanPtr) {
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
+ if (threadActionProc != NULL) {
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_REMOVE);
+ }
+ chanPtr= chanPtr->upChanPtr;
}
}
@@ -2495,10 +2788,11 @@ Tcl_CutChannel(chan)
*----------------------------------------------------------------------
*
* Tcl_SpliceChannel --
+ * SpliceChannel --
*
- * Adds a channel to the (thread-)global list of all channels
- * (in that thread). Expects that the field 'nextChanPtr' in
- * the channel is set to NULL.
+ * Adds a channel to the (thread-)global list of all channels (in that
+ * thread). Expects that the field 'nextChanPtr' in the channel is set to
+ * NULL.
*
* Results:
* Nothing.
@@ -2508,45 +2802,86 @@ 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
- * interpreter. */
+static void
+SpliceChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
{
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *statePtr = ((Channel *) chan)->state;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *statePtr = ((Channel *) chan)->state;
Tcl_DriverThreadActionProc *threadActionProc;
- if (statePtr->nextCSPtr != (ChannelState *) NULL) {
- panic("Tcl_SpliceChannel: trying to add channel used in different list");
+ if (statePtr->nextCSPtr != NULL) {
+ Tcl_Panic("SpliceChannel: trying to add channel used in different list");
}
- statePtr->nextCSPtr = tsdPtr->firstCSPtr;
- tsdPtr->firstCSPtr = statePtr;
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
/*
- * TIP #10. Mark the current thread as the new one managing this
- * channel. Note: 'Tcl_GetCurrentThread' returns sensible
- * values even for a non-threaded core.
+ * TIP #10. Mark the current thread as the new one managing this channel.
+ * Note: 'Tcl_GetCurrentThread' returns sensible values even for
+ * a non-threaded core.
*/
- statePtr->managingThread = Tcl_GetCurrentThread ();
+ statePtr->managingThread = Tcl_GetCurrentThread();
- /* TIP #218, Channel Thread Actions */
- threadActionProc = Tcl_ChannelThreadActionProc (Tcl_GetChannelType (chan));
+ /*
+ * TIP #218, Channel Thread Actions
+ */
+
+ 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);
+ }
+}
+
+void
+Tcl_SpliceChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
+{
+ Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *statePtr = chanPtr->state;
+ Tcl_DriverThreadActionProc *threadActionProc;
+
+ if (statePtr->nextCSPtr != NULL) {
+ Tcl_Panic("SpliceChannel: trying to add channel used in different list");
+ }
+
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
+
+ /*
+ * TIP #10. Mark the current thread as the new one managing this channel.
+ * Note: 'Tcl_GetCurrentThread' returns sensible values even for
+ * a non-threaded core.
+ */
+
+ statePtr->managingThread = Tcl_GetCurrentThread();
+
+ /*
+ * TIP #218, Channel Thread Actions
+ * For all transformations and the base channel.
+ */
+
+ while (chanPtr) {
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
+ if (threadActionProc != NULL) {
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_INSERT);
+ }
+ chanPtr= chanPtr->upChanPtr;
}
}
@@ -2565,29 +2900,30 @@ 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.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
-Tcl_Close(interp, chan)
- Tcl_Interp *interp; /* Interpreter for errors. */
- Tcl_Channel chan; /* The channel being closed. Must
- * not be referenced in any
- * interpreter. */
-{
- 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. */
+Tcl_Close(
+ Tcl_Interp *interp, /* Interpreter for errors. */
+ Tcl_Channel chan) /* The channel being closed. Must not be
+ * referenced in any interpreter. */
+{
+ CloseCallback *cbPtr; /* Iterate over close callbacks for this
+ * channel. */
+ Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of real IO channel. */
+ int result; /* Of calling FlushChannel. */
+ int flushcode;
+ int stickyError;
- if (chan == (Tcl_Channel) NULL) {
- return TCL_OK;
+ if (chan == NULL) {
+ return TCL_OK;
}
/*
@@ -2604,32 +2940,50 @@ Tcl_Close(interp, chan)
* This operation should occur at the top of a channel stack.
*/
- chanPtr = (Channel *) chan;
- statePtr = chanPtr->state;
- chanPtr = statePtr->topChanPtr;
+ chanPtr = (Channel *) chan;
+ statePtr = chanPtr->state;
+ chanPtr = statePtr->topChanPtr;
if (statePtr->refCount > 0) {
- panic("called Tcl_Close on channel with refCount > 0");
+ Tcl_Panic("called Tcl_Close on channel with refCount > 0");
}
-
+
if (statePtr->flags & CHANNEL_INCLOSE) {
if (interp) {
- Tcl_AppendResult(interp,
- "Illegal recursive call to close through close-handler of channel",
- (char *) NULL);
+ Tcl_AppendResult(interp, "Illegal recursive call to close "
+ "through close-handler of channel", NULL);
}
- return TCL_ERROR;
+ return TCL_ERROR;
}
- statePtr->flags |= CHANNEL_INCLOSE;
+ SetFlag(statePtr, CHANNEL_INCLOSE);
/*
* When the channel has an escape sequence driven encoding such as
* iso2022, the terminated escape sequence must write to the buffer.
*/
+
+ stickyError = 0;
+
if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL)
&& (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) {
- statePtr->outputEncodingFlags |= TCL_ENCODING_END;
- WriteChars(chanPtr, "", 0);
+ statePtr->outputEncodingFlags |= TCL_ENCODING_END;
+ if (WriteChars(chanPtr, "", 0) < 0) {
+ stickyError = Tcl_GetErrno();
+ }
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move an error message found in the channel bypass into the
+ * interpreter bypass. Just clear it if there is no interpreter.
+ */
+
+ if (statePtr->chanMsg != NULL) {
+ if (interp != NULL) {
+ Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
+ }
+ TclDecrRefCount(statePtr->chanMsg);
+ statePtr->chanMsg = NULL;
+ }
}
Tcl_ClearChannelHandlers(chan);
@@ -2638,27 +2992,26 @@ Tcl_Close(interp, chan)
* Invoke the registered close callbacks and delete their records.
*/
- while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
- cbPtr = statePtr->closeCbPtr;
- statePtr->closeCbPtr = cbPtr->nextPtr;
- (cbPtr->proc) (cbPtr->clientData);
- ckfree((char *) cbPtr);
+ while (statePtr->closeCbPtr != NULL) {
+ cbPtr = statePtr->closeCbPtr;
+ statePtr->closeCbPtr = cbPtr->nextPtr;
+ (cbPtr->proc)(cbPtr->clientData);
+ ckfree((char *) cbPtr);
}
- statePtr->flags &= ~CHANNEL_INCLOSE;
+ ResetFlag(statePtr, CHANNEL_INCLOSE);
/*
* Ensure that the last output buffer will be flushed.
*/
-
- if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
- statePtr->flags |= BUFFER_READY;
+
+ if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
}
/*
- * If this channel supports it, close the read side, since we don't need it
- * anymore and this will help avoid deadlocks on some channel types.
+ * If this channel supports it, close the read side, since we don't need
+ * it anymore and this will help avoid deadlocks on some channel types.
*/
if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) {
@@ -2669,14 +3022,42 @@ 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;
- if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) {
- return TCL_ERROR;
+ SetFlag(statePtr, CHANNEL_CLOSED);
+
+ flushcode = FlushChannel(interp, chanPtr, 0);
+
+ /*
+ * TIP #219.
+ * Capture error messages put by the driver into the bypass area and put
+ * them into the regular interpreter result.
+ *
+ * Notes: Due to the assertion of CHANNEL_CLOSED in the flags
+ * FlushChannel() has called CloseChannel() and thus freed all the channel
+ * structures. We must not try to access "chan" anymore, hence the NULL
+ * argument in the call below. The only place which may still contain a
+ * message is the interpreter itself, and "CloseChannel" made sure to lift
+ * any channel message it generated into it.
+ */
+
+ if (TclChanCaughtErrorBypass(interp, NULL)) {
+ result = EINVAL;
+ }
+
+ if (stickyError != 0) {
+ Tcl_SetErrno(stickyError);
+ if (interp != NULL) {
+ Tcl_SetObjResult(interp,
+ Tcl_NewStringObj(Tcl_PosixError(interp), -1));
+ }
+ flushcode = -1;
+ }
+ if ((flushcode != 0) || (result != 0)) {
+ return TCL_ERROR;
}
return TCL_OK;
}
@@ -2700,8 +3081,8 @@ Tcl_Close(interp, chan)
*/
void
-Tcl_ClearChannelHandlers (channel)
- Tcl_Channel channel;
+Tcl_ClearChannelHandlers(
+ Tcl_Channel channel)
{
ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */
EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */
@@ -2714,9 +3095,9 @@ Tcl_ClearChannelHandlers (channel)
* This operation should occur at the top of a channel stack.
*/
- chanPtr = (Channel *) channel;
- statePtr = chanPtr->state;
- chanPtr = statePtr->topChanPtr;
+ chanPtr = (Channel *) channel;
+ statePtr = chanPtr->state;
+ chanPtr = statePtr->topChanPtr;
/*
* Cancel any outstanding timer.
@@ -2725,31 +3106,27 @@ Tcl_ClearChannelHandlers (channel)
Tcl_DeleteTimerHandler(statePtr->timer);
/*
- * Remove any references to channel handlers for this channel that
- * may be about to be invoked.
+ * Remove any references to channel handlers for this channel that may be
+ * about to be invoked.
*/
- for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
- nhPtr = nhPtr->nestedHandlerPtr) {
- if (nhPtr->nextHandlerPtr &&
+ for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
+ nhPtr = nhPtr->nestedHandlerPtr) {
+ if (nhPtr->nextHandlerPtr &&
(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
nhPtr->nextHandlerPtr = NULL;
- }
+ }
}
/*
- * Remove all the channel handler records attached to the channel
- * itself.
+ * Remove all the channel handler records attached to the channel itself.
*/
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chNext) {
- chNext = chPtr->nextPtr;
- ckfree((char *) chPtr);
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) {
+ chNext = chPtr->nextPtr;
+ ckfree((char *) chPtr);
}
- statePtr->chPtr = (ChannelHandler *) NULL;
+ statePtr->chPtr = NULL;
/*
* Cancel any pending copy operation.
@@ -2771,14 +3148,12 @@ Tcl_ClearChannelHandlers (channel)
* Remove any EventScript records for this channel.
*/
- for (ePtr = statePtr->scriptRecordPtr;
- ePtr != (EventScriptRecord *) NULL;
- ePtr = eNextPtr) {
- eNextPtr = ePtr->nextPtr;
- Tcl_DecrRefCount(ePtr->scriptPtr);
- ckfree((char *) ePtr);
+ for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) {
+ eNextPtr = ePtr->nextPtr;
+ TclDecrRefCount(ePtr->scriptPtr);
+ ckfree((char *) ePtr);
}
- statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->scriptRecordPtr = NULL;
}
/*
@@ -2786,11 +3161,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.
*
@@ -2806,27 +3181,28 @@ Tcl_ClearChannelHandlers (channel)
*/
int
-Tcl_Write(chan, src, srcLen)
- Tcl_Channel chan; /* The channel to buffer output for. */
- CONST char *src; /* Data to queue in output buffer. */
- int srcLen; /* Length of data in bytes, or < 0 for
- * strlen(). */
+Tcl_Write(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ const char *src, /* Data to queue in output buffer. */
+ int srcLen) /* Length of data in bytes, or < 0 for
+ * strlen(). */
{
/*
* Always use the topmost channel of the stack
*/
+
Channel *chanPtr;
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
statePtr = ((Channel *) chan)->state;
- chanPtr = statePtr->topChanPtr;
+ chanPtr = statePtr->topChanPtr;
if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
}
if (srcLen < 0) {
- srcLen = strlen(src);
+ srcLen = strlen(src);
}
return DoWrite(chanPtr, src, srcLen);
}
@@ -2836,11 +3212,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.
*
@@ -2856,14 +3232,15 @@ Tcl_Write(chan, src, srcLen)
*/
int
-Tcl_WriteRaw(chan, src, srcLen)
- Tcl_Channel chan; /* The channel to buffer output for. */
- CONST char *src; /* Data to queue in output buffer. */
- int srcLen; /* Length of data in bytes, or < 0 for
- * strlen(). */
+Tcl_WriteRaw(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ const char *src, /* Data to queue in output buffer. */
+ int srcLen) /* Length of data in bytes, or < 0 for
+ * strlen(). */
{
Channel *chanPtr = ((Channel *) chan);
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int errorCode, written;
if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
@@ -2871,7 +3248,7 @@ Tcl_WriteRaw(chan, src, srcLen)
}
if (srcLen < 0) {
- srcLen = strlen(src);
+ srcLen = strlen(src);
}
/*
@@ -2895,11 +3272,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,
@@ -2913,13 +3290,14 @@ 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
+Tcl_WriteChars(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ const char *src, /* UTF-8 characters to queue in output
+ * buffer. */
+ int len) /* Length of string in bytes, or < 0 for
* strlen(). */
{
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
statePtr = ((Channel *) chan)->state;
@@ -2927,7 +3305,7 @@ Tcl_WriteChars(chan, src, len)
return -1;
}
- return DoWriteChars ((Channel*) chan, src, len);
+ return DoWriteChars((Channel *) chan, src, len);
}
/*
@@ -2936,11 +3314,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,
@@ -2954,36 +3332,43 @@ 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
+DoWriteChars(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ const char *src, /* UTF-8 characters to queue in output
+ * buffer. */
+ int len) /* Length of string in bytes, or < 0 for
* strlen(). */
{
/*
* Always use the topmost channel of the stack
*/
- ChannelState *statePtr; /* state info for channel */
+
+ ChannelState *statePtr; /* State info for channel */
statePtr = chanPtr->state;
- chanPtr = statePtr->topChanPtr;
+ chanPtr = statePtr->topChanPtr;
if (len < 0) {
- len = strlen(src);
+ len = strlen(src);
}
if (statePtr->encoding == NULL) {
/*
- * Inefficient way to convert UTF-8 to byte-array, but the
- * code parallels the way it is done for objects.
+ * Inefficient way to convert UTF-8 to byte-array, but the code
+ * parallels the way it is done for objects.
+ * Special case for 1-byte (used by eg [puts] for the \n) could
+ * be extended to more efficient translation of the src string.
*/
- Tcl_Obj *objPtr;
- int result;
+ int result;
- objPtr = Tcl_NewStringObj(src, len);
- src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
- result = WriteBytes(chanPtr, src, len);
- Tcl_DecrRefCount(objPtr);
+ if ((len == 1) && (UCHAR(*src) < 0xC0)) {
+ result = WriteBytes(chanPtr, src, len);
+ } else {
+ Tcl_Obj *objPtr = Tcl_NewStringObj(src, len);
+ src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
+ result = WriteBytes(chanPtr, src, len);
+ TclDecrRefCount(objPtr);
+ }
return result;
}
return WriteChars(chanPtr, src, len);
@@ -2994,17 +3379,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:
@@ -3015,20 +3400,21 @@ DoWriteChars(chanPtr, src, len)
*/
int
-Tcl_WriteObj(chan, objPtr)
- Tcl_Channel chan; /* The channel to buffer output for. */
- Tcl_Obj *objPtr; /* The object to write. */
+Tcl_WriteObj(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ Tcl_Obj *objPtr) /* The object to write. */
{
/*
* Always use the topmost channel of the stack
*/
+
Channel *chanPtr;
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
char *src;
int srcLen;
statePtr = ((Channel *) chan)->state;
- chanPtr = statePtr->topChanPtr;
+ chanPtr = statePtr->topChanPtr;
if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
@@ -3037,7 +3423,7 @@ Tcl_WriteObj(chan, objPtr)
src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
return WriteBytes(chanPtr, src, srcLen);
} else {
- src = Tcl_GetStringFromObj(objPtr, &srcLen);
+ src = TclGetStringFromObj(objPtr, &srcLen);
return WriteChars(chanPtr, src, srcLen);
}
}
@@ -3047,10 +3433,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,
@@ -3064,33 +3450,36 @@ Tcl_WriteObj(chan, objPtr)
*/
static int
-WriteBytes(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* Bytes to write. */
- int srcLen; /* Number of bytes to write. */
+WriteBytes(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ const char *src, /* Bytes to write. */
+ int srcLen) /* Number of bytes to write. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
char *dst;
- int dstMax, sawLF, savedLF, total, dstLen, toWrite;
-
+ int dstMax, sawLF, savedLF, total, dstLen, toWrite, translate;
+
total = 0;
sawLF = 0;
savedLF = 0;
+ translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
+ || (statePtr->outputTranslation != TCL_TRANSLATE_LF);
/*
- * Loop over all bytes in src, storing them in output buffer with
- * proper EOL translation.
+ * Loop over all bytes in src, storing them in output buffer with proper
+ * EOL translation.
*/
while (srcLen + savedLF > 0) {
bufPtr = statePtr->curOutPtr;
if (bufPtr == NULL) {
bufPtr = AllocChannelBuffer(statePtr->bufSize);
- statePtr->curOutPtr = bufPtr;
+ statePtr->curOutPtr = bufPtr;
}
- dst = bufPtr->buf + bufPtr->nextAdded;
- dstMax = bufPtr->bufLength - bufPtr->nextAdded;
+ dst = InsertPoint(bufPtr);
+ dstMax = SpaceLeft(bufPtr);
dstLen = dstMax;
toWrite = dstLen;
@@ -3098,25 +3487,32 @@ WriteBytes(chanPtr, src, srcLen)
toWrite = 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
- * line-based, we will need to flush it.
- */
+ if (translate) {
+ if (savedLF) {
+ /*
+ * A '\n' was left over from last call to TranslateOutputEOL()
+ * and we need to store it in this buffer. If the channel is
+ * line-based, we will need to flush it.
+ */
- *dst++ = '\n';
- dstLen--;
- sawLF++;
+ *dst++ = '\n';
+ dstLen--;
+ sawLF++;
+ }
+ if (TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite)) {
+ sawLF++;
+ }
+ dstLen += savedLF;
+ savedLF = 0;
+ if (dstLen > dstMax) {
+ savedLF = 1;
+ dstLen = dstMax;
+ }
+ } else {
+ memcpy(dst, src, toWrite);
+ dstLen = toWrite;
}
- sawLF += TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite);
- dstLen += savedLF;
- savedLF = 0;
- if (dstLen > dstMax) {
- savedLF = 1;
- dstLen = dstMax;
- }
bufPtr->nextAdded += dstLen;
if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
return -1;
@@ -3134,11 +3530,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,
@@ -3152,20 +3547,21 @@ WriteBytes(chanPtr, src, srcLen)
*/
static int
-WriteChars(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* UTF-8 string to write. */
- int srcLen; /* Length of UTF-8 string in bytes. */
+WriteChars(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ const char *src, /* UTF-8 string to write. */
+ int srcLen) /* Length of UTF-8 string in bytes. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
char *dst, *stage;
int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote;
int stageLen, toWrite, stageRead, endEncoding, result;
- int consumedSomething;
+ int consumedSomething, translate;
Tcl_Encoding encoding;
char safe[BUFFER_PADDING];
-
+
total = 0;
sawLF = 0;
savedLF = 0;
@@ -3178,6 +3574,9 @@ WriteChars(chanPtr, src, srcLen)
endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0);
+ translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
+ || (statePtr->outputTranslation != TCL_TRANSLATE_LF);
+
/*
* Loop over all UTF-8 characters in src, storing them in staging buffer
* with proper EOL translation.
@@ -3185,7 +3584,7 @@ WriteChars(chanPtr, src, srcLen)
consumedSomething = 1;
while (consumedSomething && (srcLen + savedLF + endEncoding > 0)) {
- consumedSomething = 0;
+ consumedSomething = 0;
stage = statePtr->outputStage;
stageMax = statePtr->bufSize;
stageLen = stageMax;
@@ -3195,27 +3594,34 @@ WriteChars(chanPtr, src, srcLen)
toWrite = 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).
- */
-
- *stage++ = '\n';
- stageLen--;
- sawLF++;
- }
- sawLF += TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite);
+ if (translate) {
+ if (savedLF) {
+ /*
+ * A '\n' was left over from last call to TranslateOutputEOL()
+ * and we need to store it in the staging buffer. If the channel
+ * is line-based, we will need to flush the output buffer (after
+ * translating the staging buffer).
+ */
+
+ *stage++ = '\n';
+ stageLen--;
+ sawLF++;
+ }
+ if (TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite)) {
+ sawLF++;
+ }
- stage -= savedLF;
- stageLen += savedLF;
- savedLF = 0;
+ stage -= savedLF;
+ stageLen += savedLF;
+ savedLF = 0;
- if (stageLen > stageMax) {
- savedLF = 1;
- stageLen = stageMax;
+ if (stageLen > stageMax) {
+ savedLF = 1;
+ stageLen = stageMax;
+ }
+ } else {
+ memcpy(stage, src, toWrite);
+ stageLen = toWrite;
}
src += toWrite;
srcLen -= toWrite;
@@ -3231,17 +3637,16 @@ WriteChars(chanPtr, src, srcLen)
bufPtr = AllocChannelBuffer(statePtr->bufSize);
statePtr->curOutPtr = bufPtr;
}
- dst = bufPtr->buf + bufPtr->nextAdded;
- dstLen = bufPtr->bufLength - bufPtr->nextAdded;
+ dst = InsertPoint(bufPtr);
+ dstLen = SpaceLeft(bufPtr);
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);
+
+ memcpy(dst, safe, (size_t) saved);
bufPtr->nextAdded += saved;
dst += saved;
dstLen -= saved;
@@ -3253,7 +3658,8 @@ WriteChars(chanPtr, src, srcLen)
&statePtr->outputEncodingState, dst,
dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
- /* Fix for SF #506297, reported by Martin Forssen
+ /*
+ * Fix for SF #506297, reported by Martin Forssen
* <ruric@users.sourceforge.net>.
*
* The encoding chosen in the script exposing the bug writes out
@@ -3269,13 +3675,15 @@ WriteChars(chanPtr, src, srcLen)
*/
statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
+
/*
* The following code must be executed only when result is not 0.
*/
- if (result && ((stageRead + dstWrote) == 0)) {
+
+ if ((result != 0) && (stageRead + dstWrote == 0)) {
/*
* We have an incomplete UTF-8 character at the end of the
- * staging buffer. It will get moved to the beginning of the
+ * staging buffer. It will get moved to the beginning of the
* staging buffer followed by more bytes from src.
*/
@@ -3286,18 +3694,17 @@ WriteChars(chanPtr, src, srcLen)
break;
}
bufPtr->nextAdded += dstWrote;
- if (bufPtr->nextAdded > bufPtr->bufLength) {
+ if (IsBufferOverflowing(bufPtr)) {
/*
* 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;
- memcpy((VOID *) safe, (VOID *) (dst + dstLen), (size_t) saved);
+ saved = -SpaceLeft(bufPtr);
+ memcpy(safe, dst + dstLen, (size_t) saved);
bufPtr->nextAdded = bufPtr->bufLength;
}
if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
@@ -3323,13 +3730,14 @@ 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)) {
- Tcl_SetErrno (EINVAL);
- return -1;
+ Tcl_SetErrno(EINVAL);
+ return -1;
}
return total;
}
@@ -3339,125 +3747,120 @@ 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.
*
*---------------------------------------------------------------------------
*/
static int
-TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
- ChannelState *statePtr; /* Channel being read, for translation and
+TranslateOutputEOL(
+ ChannelState *statePtr, /* Channel being read, for translation and
* buffering modes. */
- char *dst; /* Output buffer filled with UTF-8 chars by
+ char *dst, /* Output buffer filled with UTF-8 chars by
* applying appropriate EOL translation to
* source characters. */
- CONST char *src; /* Source UTF-8 characters. */
- int *dstLenPtr; /* On entry, the maximum length of output
- * buffer in bytes. On exit, the number of
+ const char *src, /* Source UTF-8 characters. */
+ int *dstLenPtr, /* On entry, the maximum length of output
+ * buffer in bytes. On exit, the number of
* bytes actually used in output buffer. */
- int *srcLenPtr; /* On entry, the length of source buffer.
- * On exit, the number of bytes read from
- * the source buffer. */
+ int *srcLenPtr) /* On entry, the length of source buffer. On
+ * exit, the number of bytes read from the
+ * source buffer. */
{
char *dstEnd;
int srcLen, newlineFound;
-
+
newlineFound = 0;
srcLen = *srcLenPtr;
switch (statePtr->outputTranslation) {
- case TCL_TRANSLATE_LF: {
- for (dstEnd = dst + srcLen; dst < dstEnd; ) {
- if (*src == '\n') {
- newlineFound = 1;
- }
- *dst++ = *src++;
+ 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;
-
- dstStart = dst;
- dstMax = dst + *dstLenPtr;
+ char *dstStart, *dstMax;
+ const char *srcStart;
- 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;
+ dstStart = dst;
+ dstMax = dst + *dstLenPtr;
+
+ srcStart = src;
+
+ 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;
}
@@ -3467,12 +3870,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.
@@ -3481,13 +3884,15 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
*/
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. */
+CheckFlush(
+ Channel *chanPtr, /* Channel being read, for buffering mode. */
+ ChannelBuffer *bufPtr, /* Channel buffer to possibly flush. */
+ int newlineFlag) /* Non-zero if a the channel buffer contains a
+ * newline. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+
/*
* The current buffer is ready for output:
* 1. if it is full.
@@ -3496,14 +3901,14 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
*/
if ((statePtr->flags & BUFFER_READY) == 0) {
- if (bufPtr->nextAdded == bufPtr->bufLength) {
- statePtr->flags |= BUFFER_READY;
+ if (IsBufferFull(bufPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
} else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
if (newlineFlag != 0) {
- statePtr->flags |= BUFFER_READY;
+ SetFlag(statePtr, BUFFER_READY);
}
} else if (statePtr->flags & CHANNEL_UNBUFFERED) {
- statePtr->flags |= BUFFER_READY;
+ SetFlag(statePtr, BUFFER_READY);
}
}
if (statePtr->flags & BUFFER_READY) {
@@ -3527,17 +3932,17 @@ 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.
*
*---------------------------------------------------------------------------
*/
int
-Tcl_Gets(chan, lineRead)
- Tcl_Channel chan; /* Channel from which to read. */
- Tcl_DString *lineRead; /* The line read will be appended to this
- * DString as UTF-8 characters. The caller
+Tcl_Gets(
+ Tcl_Channel chan, /* Channel from which to read. */
+ Tcl_DString *lineRead) /* The line read will be appended to this
+ * DString as UTF-8 characters. The caller
* must have initialized it and is responsible
* for managing the storage. */
{
@@ -3545,13 +3950,13 @@ Tcl_Gets(chan, lineRead)
int charsStored, length;
char *string;
- objPtr = Tcl_NewObj();
+ TclNewObj(objPtr);
charsStored = Tcl_GetsObj(chan, objPtr);
if (charsStored > 0) {
- string = Tcl_GetStringFromObj(objPtr, &length);
+ string = TclGetStringFromObj(objPtr, &length);
Tcl_DStringAppend(lineRead, string, length);
}
- Tcl_DecrRefCount(objPtr);
+ TclDecrRefCount(objPtr);
return charsStored;
}
@@ -3561,60 +3966,71 @@ 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.
*
*---------------------------------------------------------------------------
*/
int
-Tcl_GetsObj(chan, objPtr)
- Tcl_Channel chan; /* Channel from which to read. */
- Tcl_Obj *objPtr; /* The line read will be appended to this
+Tcl_GetsObj(
+ Tcl_Channel chan, /* Channel from which to read. */
+ Tcl_Obj *objPtr) /* The line read will be appended to this
* object as UTF-8 characters. */
{
GetsState gs;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
Tcl_Encoding encoding;
char *dst, *dstEnd, *eol, *eof;
Tcl_EncodingState oldState;
+ if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
+ copiedTotal = -1;
+ goto done;
+ }
+
+ /*
+ * A binary version of Tcl_GetsObj. This could also handle encodings that
+ * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion
+ * done on objPtr.
+ */
+
+ if ((statePtr->encoding == NULL)
+ && ((statePtr->inputTranslation == TCL_TRANSLATE_LF)
+ || (statePtr->inputTranslation == TCL_TRANSLATE_CR))) {
+ return TclGetsObjBinary(chan, objPtr);
+ }
+
/*
* This operation should occur at the top of a channel stack.
*/
chanPtr = statePtr->topChanPtr;
- if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
- copiedTotal = -1;
- goto done;
- }
-
bufPtr = statePtr->inQueueHead;
encoding = statePtr->encoding;
/*
- * Preserved so we can restore the channel's state in case we don't
- * find a newline in the available input.
+ * Preserved so we can restore the channel's state in case we don't find a
+ * newline in the available input.
*/
- Tcl_GetStringFromObj(objPtr, &oldLength);
+ TclGetStringFromObj(objPtr, &oldLength);
oldFlags = statePtr->inputEncodingFlags;
oldState = statePtr->inputEncodingState;
oldRemoved = BUFFER_PADDING;
@@ -3624,17 +4040,25 @@ Tcl_GetsObj(chan, objPtr)
/*
* If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't
- * produce ByteArray objects. To avoid circularity problems,
- * "iso8859-1" is builtin to Tcl.
+ * produce ByteArray objects.
*/
if (encoding == NULL) {
- encoding = Tcl_GetEncoding(NULL, "iso8859-1");
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+ if (tsdPtr->binaryEncoding == NULL) {
+ tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1");
+ Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL);
+ }
+ encoding = tsdPtr->binaryEncoding;
+ if (encoding == NULL) {
+ Tcl_Panic("attempted gets on binary channel where no iso8859-1 encoding available");
+ }
}
/*
- * 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;
@@ -3661,10 +4085,10 @@ Tcl_GetsObj(chan, objPtr)
}
dstEnd = dst + gs.bytesWrote;
}
-
+
/*
- * Remember if EOF char is seen, then look for EOL anyhow, because
- * the EOL might be before the EOF char.
+ * Remember if EOF char is seen, then look for EOL anyhow, because the
+ * EOL might be before the EOF char.
*/
if (inEofChar != '\0') {
@@ -3683,31 +4107,37 @@ 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++;
- if (eol >= dstEnd) {
- int offset;
-
+ break;
+ case TCL_TRANSLATE_CRLF:
+ for (eol = dst; eol < dstEnd; eol++) {
+ if (*eol == '\r') {
+ eol++;
+
+ /*
+ * If a CR is at the end of the buffer, then check for a
+ * LF at the begining of the next buffer, unless EOF char
+ * was found already.
+ */
+
+ if (eol >= dstEnd) {
+ int offset;
+
+ if (eol != eof) {
offset = eol - objPtr->bytes;
dst = dstEnd;
if (FilterInputBytes(chanPtr, &gs) != 0) {
@@ -3715,88 +4145,89 @@ Tcl_GetsObj(chan, objPtr)
}
dstEnd = dst + gs.bytesWrote;
eol = objPtr->bytes + offset;
- if (eol >= dstEnd) {
- skip = 0;
- goto goteol;
- }
}
- if (*eol == '\n') {
- eol--;
- skip = 2;
- goto goteol;
+ 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 == '\n') {
- /*
- * Skip the raw bytes that make up the '\n'.
- */
+ break;
+ case TCL_TRANSLATE_AUTO:
+ eol = dst;
+ skip = 1;
+ if (statePtr->flags & INPUT_SAW_CR) {
+ ResetFlag(statePtr, INPUT_SAW_CR);
+ if ((eol < dstEnd) && (*eol == '\n')) {
+ /*
+ * Skip the raw bytes that make up the '\n'.
+ */
- char tmp[1 + TCL_UTF_MAX];
- int rawRead;
-
- bufPtr = gs.bufPtr;
- Tcl_ExternalToUtf(NULL, gs.encoding,
- 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--;
- }
+ char tmp[1 + TCL_UTF_MAX];
+ int rawRead;
+
+ bufPtr = gs.bufPtr;
+ Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr),
+ gs.rawRead, statePtr->inputEncodingFlags,
+ &gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead, NULL,
+ NULL);
+ bufPtr->nextRemoved += rawRead;
+ gs.rawRead -= rawRead;
+ gs.bytesWrote--;
+ gs.charsWrote--;
+ memmove(dst, dst + 1, (size_t) (dstEnd - dst));
+ dstEnd--;
}
- 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.
- */
+ }
+ 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, unless EOF char was found already.
+ */
+ if (eol != eof) {
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++;
+
+ if (eol >= dstEnd) {
+ eol--;
+ SetFlag(statePtr, 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;
}
}
}
if (eof != NULL) {
/*
- * EOF character was seen. On EOF, leave current file position
+ * EOF character was seen. On EOF, leave current file position
* pointing at the EOF character, but don't store the EOF
* character in the output string.
*/
dstEnd = eof;
- statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
}
if (statePtr->flags & CHANNEL_EOF) {
@@ -3809,29 +4240,31 @@ Tcl_GetsObj(chan, objPtr)
*/
Tcl_SetObjLength(objPtr, oldLength);
- CommonGetsCleanup(chanPtr, encoding);
+ CommonGetsCleanup(chanPtr);
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;
+ if (bufPtr == NULL) {
+ Tcl_Panic("Tcl_GetsObj: gotEOL reached with bufPtr==NULL");
+ }
statePtr->inputEncodingState = gs.state;
- Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved,
- gs.rawRead, statePtr->inputEncodingFlags,
- &statePtr->inputEncodingState, dst,
+ Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), gs.rawRead,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst,
eol - dst + skip + TCL_UTF_MAX, &gs.rawRead, NULL,
&gs.charsWrote);
bufPtr->nextRemoved += gs.rawRead;
@@ -3841,25 +4274,28 @@ Tcl_GetsObj(chan, objPtr)
*/
Tcl_SetObjLength(objPtr, eol - objPtr->bytes);
- CommonGetsCleanup(chanPtr, encoding);
- statePtr->flags &= ~CHANNEL_BLOCKED;
+ CommonGetsCleanup(chanPtr);
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
copiedTotal = gs.totalChars + gs.charsWrote - skip;
goto done;
/*
- * Couldn't get a complete line. This only happens if we get a error
- * reading from the channel or we are non-blocking and there wasn't
- * an EOL or EOF in the data available.
+ * Couldn't get a complete line. This only happens if we get a error
+ * reading from the channel or we are non-blocking and there wasn't an EOL
+ * or EOF in the data available.
*/
- restore:
+ restore:
bufPtr = statePtr->inQueueHead;
+ if (bufPtr == NULL) {
+ Tcl_Panic("Tcl_GetsObj: restore reached with bufPtr==NULL");
+ }
bufPtr->nextRemoved = oldRemoved;
for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
bufPtr->nextRemoved = BUFFER_PADDING;
}
- CommonGetsCleanup(chanPtr, encoding);
+ CommonGetsCleanup(chanPtr);
statePtr->inputEncodingState = oldState;
statePtr->inputEncodingFlags = oldFlags;
@@ -3867,66 +4303,336 @@ 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
- * state. Note that this means a file event will not be delivered even
- * though a read would be able to consume the buffered data.
+ * that the gets blocked. It will wait for more data instead of firing a
+ * timer, avoiding a busy wait. This is where we are assuming that the
+ * next operation is a gets. No more file events will be delivered on this
+ * channel until new data arrives or some operation is performed on the
+ * channel (e.g. gets, read, fconfigure) that changes the blocking state.
+ * Note that this means a file event will not be delivered even though a
+ * read would be able to consume the buffered data.
*/
- statePtr->flags |= CHANNEL_NEED_MORE_DATA;
+ SetFlag(statePtr, 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;
}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TclGetsObjBinary --
+ *
+ * A variation of Tcl_GetsObj that works directly on the buffers until
+ * end-of-line or end-of-file has been seen. Bytes read from the input
+ * channel return as a ByteArray obj.
+ *
+ * Results:
+ * Number of characters accumulated in the object or -1 if error,
+ * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error
+ * code for the error or condition that occurred.
+ *
+ * Side effects:
+ * Consumes input from the channel.
+ *
+ * On reading EOF, leave channel pointing at EOF char. On reading EOL,
+ * leave channel pointing after EOL, but don't return EOL in dst buffer.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+TclGetsObjBinary(
+ Tcl_Channel chan, /* Channel from which to read. */
+ Tcl_Obj *objPtr) /* The line read will be appended to this
+ * object as UTF-8 characters. */
+{
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ ChannelBuffer *bufPtr;
+ int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
+ int rawLen, byteLen, eolChar;
+ unsigned char *dst, *dstEnd, *eol, *eof, *byteArray;
+
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ bufPtr = statePtr->inQueueHead;
+
+ /*
+ * Preserved so we can restore the channel's state in case we don't find a
+ * newline in the available input.
+ */
+
+ byteArray = Tcl_GetByteArrayFromObj(objPtr, &byteLen);
+ oldFlags = statePtr->inputEncodingFlags;
+ oldRemoved = BUFFER_PADDING;
+ oldLength = byteLen;
+ if (bufPtr != NULL) {
+ oldRemoved = bufPtr->nextRemoved;
+ }
+
+ rawLen = 0;
+ skip = 0;
+ eof = NULL;
+ inEofChar = statePtr->inEofChar;
+ /* Only handle TCL_TRANSLATE_LF and TCL_TRANSLATE_CR */
+ eolChar = (statePtr->inputTranslation == TCL_TRANSLATE_LF) ? '\n' : '\r';
+
+ while (1) {
+ /*
+ * Subtract the number of bytes that were removed from channel
+ * buffer during last call.
+ */
+
+ if (bufPtr != NULL) {
+ bufPtr->nextRemoved += rawLen;
+ if (!IsBufferReady(bufPtr)) {
+ bufPtr = bufPtr->nextPtr;
+ }
+ }
+
+ if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) {
+ /*
+ * All channel buffers were exhausted and the caller still
+ * hasn't seen EOL. Need to read more bytes from the channel
+ * device. Side effect is to allocate another channel buffer.
+ */
+
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
+ goto restore;
+ }
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
+ }
+ if (GetInput(chanPtr) != 0) {
+ goto restore;
+ }
+ bufPtr = statePtr->inQueueTail;
+ }
+
+ dst = (unsigned char *) RemovePoint(bufPtr);
+ dstEnd = dst + BytesLeft(bufPtr);
+
+ /*
+ * Remember if EOF char is seen, then look for EOL anyhow, because the
+ * EOL might be before the EOF char.
+ * XXX - in the binary case, consider coincident search for eol/eof.
+ */
+
+ if (inEofChar != '\0') {
+ for (eol = dst; eol < dstEnd; eol++) {
+ if (*eol == inEofChar) {
+ dstEnd = eol;
+ eof = eol;
+ break;
+ }
+ }
+ }
+
+ /*
+ * On EOL, leave current file position pointing after the EOL, but
+ * don't store the EOL in the output string.
+ */
+
+ for (eol = dst; eol < dstEnd; eol++) {
+ if (*eol == eolChar) {
+ skip = 1;
+ goto gotEOL;
+ }
+ }
+ if (eof != NULL) {
+ /*
+ * EOF character was seen. On EOF, leave current file position
+ * pointing at the EOF character, but don't store the EOF
+ * character in the output string.
+ */
+
+ SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+ }
+ if (statePtr->flags & CHANNEL_EOF) {
+ skip = 0;
+ eol = dstEnd;
+ if ((dst == dstEnd) && (byteLen == oldLength)) {
+ /*
+ * If we didn't append any bytes before encountering EOF,
+ * caller needs to see -1.
+ */
+
+ byteArray = Tcl_SetByteArrayLength(objPtr, oldLength);
+ CommonGetsCleanup(chanPtr);
+ copiedTotal = -1;
+ goto done;
+ }
+ goto gotEOL;
+ }
+
+ /*
+ * Copy bytes from the channel buffer to the ByteArray.
+ * This may realloc space, so keep track of result.
+ */
+
+ rawLen = dstEnd - dst;
+ byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen);
+ memcpy(byteArray + byteLen, dst, (size_t) rawLen);
+ byteLen += rawLen;
+ }
+
+ /*
+ * Found EOL or EOF, but the output buffer may now contain too many bytes.
+ * We need to know how many bytes correspond to the number we want, so we
+ * can remove the correct number of bytes from the channel buffer.
+ */
+
+ gotEOL:
+ if (bufPtr == NULL) {
+ Tcl_Panic("TclGetsObjBinary: gotEOL reached with bufPtr==NULL");
+ }
+
+ rawLen = eol - dst;
+ byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen);
+ memcpy(byteArray + byteLen, dst, (size_t) rawLen);
+ byteLen += rawLen;
+ bufPtr->nextRemoved += rawLen + skip;
+
+ /*
+ * Convert the buffer if there was an encoding.
+ * XXX - unimplemented.
+ */
+
+ if (statePtr->encoding != NULL) {
+ }
+
+ /*
+ * Recycle all the emptied buffers.
+ */
+
+ CommonGetsCleanup(chanPtr);
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
+ copiedTotal = byteLen;
+ goto done;
+
+ /*
+ * Couldn't get a complete line. This only happens if we get a error
+ * reading from the channel or we are non-blocking and there wasn't an EOL
+ * or EOF in the data available.
+ */
+
+ restore:
+ bufPtr = statePtr->inQueueHead;
+ if (bufPtr == NULL) {
+ Tcl_Panic("TclGetsObjBinary: restore reached with bufPtr==NULL");
+ }
+ bufPtr->nextRemoved = oldRemoved;
+
+ for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
+ bufPtr->nextRemoved = BUFFER_PADDING;
+ }
+ CommonGetsCleanup(chanPtr);
+
+ statePtr->inputEncodingFlags = oldFlags;
+ byteArray = Tcl_SetByteArrayLength(objPtr, oldLength);
+
+ /*
+ * We didn't get a complete line so we need to indicate to UpdateInterest
+ * that the gets blocked. It will wait for more data instead of firing a
+ * timer, avoiding a busy wait. This is where we are assuming that the
+ * next operation is a gets. No more file events will be delivered on this
+ * channel until new data arrives or some operation is performed on the
+ * channel (e.g. gets, read, fconfigure) that changes the blocking state.
+ * Note that this means a file event will not be delivered even though a
+ * read would be able to consume the buffered data.
+ */
+
+ SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+ copiedTotal = -1;
+
+ /*
+ * Update the notifier state so we don't block while there is still data
+ * in the buffers.
+ */
+
+ done:
+ UpdateInterest(chanPtr);
+ return copiedTotal;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FreeBinaryEncoding --
+ *
+ * Frees any "iso8859-1" Tcl_Encoding created by [gets] on a binary
+ * channel in a thread as part of that thread's finalization.
+ *
+ * Results:
+ * None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+FreeBinaryEncoding(
+ ClientData dummy) /* Not used */
+{
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ if (tsdPtr->binaryEncoding != NULL) {
+ Tcl_FreeEncoding(tsdPtr->binaryEncoding);
+ tsdPtr->binaryEncoding = NULL;
+ }
+}
+
/*
*---------------------------------------------------------------------------
*
* FilterInputBytes --
*
- * Helper function for Tcl_GetsObj. Produces UTF-8 characters from
- * raw bytes read from the channel.
+ * Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw
+ * bytes read from the channel.
*
- * Consumes available bytes from channel buffers. When channel
- * buffers are exhausted, reads more bytes from channel device into
- * a new channel buffer. It is the caller's responsibility to
- * free the channel buffers that have been exhausted.
+ * Consumes available bytes from channel buffers. When channel buffers
+ * are exhausted, reads more bytes from channel device into a new channel
+ * buffer. It is the caller's responsibility to free the channel buffers
+ * that have been exhausted.
*
* Results:
- * The return value is -1 if there was an error reading from the
- * channel, 0 otherwise.
+ * The return value is -1 if there was an error reading from the channel,
+ * 0 otherwise.
*
* Side effects:
- * Status object keeps track of how much data from channel buffers
- * has been consumed and where UTF-8 bytes should be stored.
+ * Status object keeps track of how much data from channel buffers has
+ * been consumed and where UTF-8 bytes should be stored.
*
*---------------------------------------------------------------------------
*/
-
+
static int
-FilterInputBytes(chanPtr, gsPtr)
- Channel *chanPtr; /* Channel to read. */
- GetsState *gsPtr; /* Current state of gets operation. */
+FilterInputBytes(
+ Channel *chanPtr, /* Channel to read. */
+ GetsState *gsPtr) /* Current state of gets operation. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
- char *raw, *rawStart, *rawEnd;
- char *dst;
- int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length;
+ char *raw, *rawStart, *dst;
+ int offset, toRead, dstNeeded, spaceLeft, result, rawLen;
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. */
@@ -3941,7 +4647,7 @@ FilterInputBytes(chanPtr, gsPtr)
bufPtr = gsPtr->bufPtr;
if (bufPtr != NULL) {
bufPtr->nextRemoved += gsPtr->rawRead;
- if (bufPtr->nextRemoved >= bufPtr->nextAdded) {
+ if (!IsBufferReady(bufPtr)) {
bufPtr = bufPtr->nextPtr;
}
}
@@ -3949,20 +4655,20 @@ 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:
- if (statePtr->flags & CHANNEL_BLOCKED) {
- if (statePtr->flags & CHANNEL_NONBLOCKING) {
+ read:
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
gsPtr->charsWrote = 0;
gsPtr->rawRead = 0;
return -1;
}
- statePtr->flags &= ~CHANNEL_BLOCKED;
- }
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
+ }
if (GetInput(chanPtr) != 0) {
gsPtr->charsWrote = 0;
gsPtr->rawRead = 0;
@@ -3973,15 +4679,14 @@ FilterInputBytes(chanPtr, gsPtr)
}
/*
- * Convert some of the bytes from the channel buffer to UTF-8. Space in
- * objPtr's string rep is used to hold the UTF-8 characters. Grow the
+ * Convert some of the bytes from the channel buffer to UTF-8. Space in
+ * objPtr's string rep is used to hold the UTF-8 characters. Grow the
* string rep if we need more space.
*/
- rawStart = bufPtr->buf + bufPtr->nextRemoved;
+ rawStart = RemovePoint(bufPtr);
raw = rawStart;
- rawEnd = bufPtr->buf + bufPtr->nextAdded;
- rawLen = rawEnd - rawStart;
+ rawLen = BytesLeft(bufPtr);
dst = *gsPtr->dstPtr;
offset = dst - objPtr->bytes;
@@ -3989,15 +4694,19 @@ FilterInputBytes(chanPtr, gsPtr)
if (toRead > rawLen) {
toRead = rawLen;
}
- dstNeeded = toRead * TCL_UTF_MAX + 1;
- spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1;
+ dstNeeded = toRead * TCL_UTF_MAX;
+ spaceLeft = objPtr->length - offset;
if (dstNeeded > spaceLeft) {
- length = offset * 2;
- if (offset < dstNeeded) {
+ int length = offset + ((offset < dstNeeded) ? dstNeeded : offset);
+
+ if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
length = offset + dstNeeded;
+ if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
+ dstNeeded = TCL_UTF_MAX - 1 + toRead;
+ length = offset + dstNeeded;
+ Tcl_SetObjLength(objPtr, length);
+ }
}
- length += TCL_UTF_MAX + 1;
- Tcl_SetObjLength(objPtr, length);
spaceLeft = length - offset;
dst = objPtr->bytes + offset;
*gsPtr->dstPtr = dst;
@@ -4005,44 +4714,45 @@ FilterInputBytes(chanPtr, gsPtr)
gsPtr->state = statePtr->inputEncodingState;
result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen,
statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
- dst, spaceLeft, &gsPtr->rawRead, &gsPtr->bytesWrote,
+ dst, spaceLeft+1, &gsPtr->rawRead, &gsPtr->bytesWrote,
&gsPtr->charsWrote);
/*
* Make sure that if we go through 'gets', that we reset the
- * TCL_ENCODING_START flag still. [Bug #523988]
+ * TCL_ENCODING_START flag still. [Bug #523988]
*/
+
statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
if (result == TCL_CONVERT_MULTIBYTE) {
/*
* The last few bytes in this channel buffer were the start of a
- * multibyte sequence. If this buffer was full, then move them to
- * the next buffer so the bytes will be contiguous.
+ * multibyte sequence. If this buffer was full, then move them to the
+ * next buffer so the bytes will be contiguous.
*/
ChannelBuffer *nextPtr;
int extra;
-
+
nextPtr = bufPtr->nextPtr;
- if (bufPtr->nextAdded < bufPtr->bufLength) {
+ if (!IsBufferFull(bufPtr)) {
if (gsPtr->rawRead > 0) {
/*
- * Some raw bytes were converted to UTF-8. Fall through,
+ * Some raw bytes were converted to UTF-8. Fall through,
* returning those UTF-8 characters because a EOL might be
* present in them.
*/
} else if (statePtr->flags & CHANNEL_EOF) {
/*
* There was a partial character followed by EOF on the
- * device. Fall through, returning that nothing was found.
+ * device. Fall through, returning that nothing was found.
*/
bufPtr->nextRemoved = bufPtr->nextAdded;
} else {
/*
- * There are no more cached raw bytes left. See if we can
- * get some more.
+ * There are no more cached raw bytes left. See if we can get
+ * some more.
*/
goto read;
@@ -4054,8 +4764,8 @@ FilterInputBytes(chanPtr, gsPtr)
statePtr->inQueueTail = nextPtr;
}
extra = rawLen - gsPtr->rawRead;
- memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
- (VOID *) (raw + gsPtr->rawRead), (size_t) extra);
+ memcpy(nextPtr->buf + BUFFER_PADDING - extra,
+ raw + gsPtr->rawRead, (size_t) extra);
nextPtr->nextRemoved -= extra;
bufPtr->nextAdded -= extra;
}
@@ -4070,9 +4780,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
@@ -4088,13 +4798,14 @@ 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. */
- GetsState *gsPtr; /* Current state of gets operation. */
+PeekAhead(
+ Channel *chanPtr, /* The channel to read. */
+ char **dstEndPtr, /* Filled with pointer to end of new range of
+ * UTF-8 characters. */
+ GetsState *gsPtr) /* Current state of gets operation. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
Tcl_DriverBlockModeProc *blockModeProc;
int bytesLeft;
@@ -4103,21 +4814,21 @@ 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;
if (bufPtr->nextPtr == NULL) {
- bytesLeft = bufPtr->nextAdded - (bufPtr->nextRemoved + gsPtr->rawRead);
+ bytesLeft = BytesLeft(bufPtr) - gsPtr->rawRead;
if (bytesLeft == 0) {
- if (bufPtr->nextAdded < bufPtr->bufLength) {
+ if (!IsBufferFull(bufPtr)) {
/*
* Don't peek ahead if last read was short read.
*/
-
+
goto cleanup;
}
if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) {
@@ -4141,7 +4852,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
}
return;
- cleanup:
+ cleanup:
bufPtr->nextRemoved += gsPtr->rawRead;
gsPtr->rawRead = 0;
gsPtr->totalChars += gsPtr->charsWrote;
@@ -4154,8 +4865,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.
@@ -4165,19 +4876,19 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
*
*---------------------------------------------------------------------------
*/
-
+
static void
-CommonGetsCleanup(chanPtr, encoding)
- Channel *chanPtr;
- Tcl_Encoding encoding;
+CommonGetsCleanup(
+ Channel *chanPtr)
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr, *nextPtr;
-
+
bufPtr = statePtr->inQueueHead;
for ( ; bufPtr != NULL; bufPtr = nextPtr) {
nextPtr = bufPtr->nextPtr;
- if (bufPtr->nextRemoved < bufPtr->nextAdded) {
+ if (IsBufferReady(bufPtr)) {
break;
}
RecycleBuffer(statePtr, bufPtr, 0);
@@ -4189,20 +4900,20 @@ CommonGetsCleanup(chanPtr, encoding)
/*
* If any multi-byte characters were split across channel buffer
* boundaries, the split-up bytes were moved to the next channel
- * buffer by FilterInputBytes(). Move the bytes back to their
- * original buffer because the caller could change the channel's
- * encoding which could change the interpretation of whether those
- * bytes really made up multi-byte characters after all.
+ * buffer by FilterInputBytes(). Move the bytes back to their original
+ * buffer because the caller could change the channel's encoding which
+ * could change the interpretation of whether those bytes really made
+ * up multi-byte characters after all.
*/
-
+
nextPtr = bufPtr->nextPtr;
for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) {
int extra;
- extra = bufPtr->bufLength - bufPtr->nextAdded;
+ extra = SpaceLeft(bufPtr);
if (extra > 0) {
- memcpy((VOID *) (bufPtr->buf + bufPtr->nextAdded),
- (VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
+ memcpy(InsertPoint(bufPtr),
+ nextPtr->buf + BUFFER_PADDING - extra,
(size_t) extra);
bufPtr->nextAdded += extra;
nextPtr->nextRemoved = BUFFER_PADDING;
@@ -4210,9 +4921,6 @@ CommonGetsCleanup(chanPtr, encoding)
bufPtr = nextPtr;
}
}
- if (statePtr->encoding == NULL) {
- Tcl_FreeEncoding(encoding);
- }
}
/*
@@ -4220,16 +4928,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 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.
@@ -4238,13 +4946,14 @@ CommonGetsCleanup(chanPtr, encoding)
*/
int
-Tcl_Read(chan, dst, bytesToRead)
- Tcl_Channel chan; /* The channel from which to read. */
- char *dst; /* Where to store input read. */
- int bytesToRead; /* Maximum number of bytes to read. */
+Tcl_Read(
+ Tcl_Channel chan, /* The channel from which to read. */
+ char *dst, /* Where to store input read. */
+ int bytesToRead) /* Maximum number of bytes to read. */
{
- Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* This operation should occur at the top of a channel stack.
@@ -4264,16 +4973,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 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.
@@ -4282,22 +4991,22 @@ Tcl_Read(chan, dst, bytesToRead)
*/
int
-Tcl_ReadRaw(chan, bufPtr, bytesToRead)
- Tcl_Channel chan; /* The channel from which to read. */
- char *bufPtr; /* Where to store input read. */
- int bytesToRead; /* Maximum number of bytes to read. */
+Tcl_ReadRaw(
+ Tcl_Channel chan, /* The channel from which to read. */
+ char *bufPtr, /* Where to store input read. */
+ int bytesToRead) /* Maximum number of bytes to read. */
{
- Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
- int nread, result;
- int copied, copiedNow;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ int nread, result, copied, copiedNow;
/*
* The check below does too much because it will reject a call to this
* function with a channel which is part of an 'fcopy'. But we have to
- * allow this here or else the chaining in the transformation drivers
- * will fail with 'file busy' error instead of retrieving and
- * transforming the data to copy.
+ * allow this here or else the chaining in the transformation drivers will
+ * fail with 'file busy' error instead of retrieving and transforming the
+ * data to copy.
*
* We let the check procedure now believe that there is no fcopy in
* progress. A better solution than this might be an additional flag
@@ -4309,102 +5018,113 @@ 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) {
- copiedNow = CopyBuffer(chanPtr, bufPtr + copied,
- bytesToRead - copied);
- if (copiedNow == 0) {
- if (statePtr->flags & CHANNEL_EOF) {
+ copiedNow = CopyBuffer(chanPtr, bufPtr + copied,
+ bytesToRead - copied);
+ if (copiedNow == 0) {
+ if (statePtr->flags & CHANNEL_EOF) {
goto done;
- }
- if (statePtr->flags & CHANNEL_BLOCKED) {
- if (statePtr->flags & CHANNEL_NONBLOCKING) {
+ }
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
goto done;
- }
- statePtr->flags &= (~(CHANNEL_BLOCKED));
- }
+ }
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
+ }
#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.
+ /*
+ * [Bug 943274]. Better emulation of non-blocking channels for
+ * channels without BlockModeProc, by keeping track of true
+ * fileevents generated by the OS == Data waiting and reading if
+ * and only if we are sure to have data.
*/
if ((statePtr->flags & CHANNEL_NONBLOCKING) &&
- (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
- !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
+ (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
+ !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
+ /*
+ * 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;
+ nread = -1;
+ result = EWOULDBLOCK;
} else {
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
- /*
- * Now go to the driver to get as much as is possible to
- * fill the remaining request. Do all the error handling
- * by ourselves. The code was stolen from 'GetInput' and
- * slightly adapted (different return value here).
- *
- * The case of 'bytesToRead == 0' at this point cannot happen.
- */
-
- nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
- bufPtr + copied, bytesToRead - copied, &result);
+
+ /*
+ * Now go to the driver to get as much as is possible to fill
+ * the remaining request. Do all the error handling by
+ * ourselves. The code was stolen from 'GetInput' and slightly
+ * adapted (different return value here).
+ *
+ * The case of 'bytesToRead == 0' at this point cannot happen.
+ */
+
+ nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+ bufPtr + copied, bytesToRead - copied, &result);
+
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
+
if (nread > 0) {
- /*
- * If we get a short read, signal up that we may be
- * BLOCKED. We should avoid calling the driver because
- * on some platforms we will block in the low level
- * reading code even though the channel is set into
- * nonblocking mode.
+ /*
+ * If we get a short read, signal up that we may be BLOCKED.
+ * We should avoid calling the driver because on some
+ * platforms we will block in the low level reading code even
+ * though the channel is set into nonblocking mode.
*/
-
- if (nread < (bytesToRead - copied)) {
- statePtr->flags |= CHANNEL_BLOCKED;
+
+ if (nread < (bytesToRead - copied)) {
+ SetFlag(statePtr, CHANNEL_BLOCKED);
}
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
- if (nread <= (bytesToRead - copied)) {
- /* [SF Tcl Bug 943274] We have read the available
- * data, clear flag */
- statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
+ if (nread <= (bytesToRead - copied)) {
+ /*
+ * [Bug 943274] We have read the available data, clear
+ * flag.
+ */
+
+ ResetFlag(statePtr, CHANNEL_HAS_MORE_DATA);
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
+
} else if (nread == 0) {
- statePtr->flags |= CHANNEL_EOF;
+ SetFlag(statePtr, CHANNEL_EOF);
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+
} else if (nread < 0) {
- if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
+ if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
if (copied > 0) {
- /*
- * Information that was copied earlier has precedence
- * over EAGAIN/WOULDBLOCK handling.
- */
- return copied;
+ /*
+ * Information that was copied earlier has precedence
+ * over EAGAIN/WOULDBLOCK handling.
+ */
+
+ return copied;
}
- statePtr->flags |= CHANNEL_BLOCKED;
+ SetFlag(statePtr, CHANNEL_BLOCKED);
result = EAGAIN;
}
Tcl_SetErrno(result);
return -1;
- }
+ }
return copied + nread;
- }
+ }
}
-done:
+ done:
return copied;
}
@@ -4413,39 +5133,39 @@ 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.
*
*---------------------------------------------------------------------------
*/
-
+
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 appendFlag; /* If non-zero, data read from the channel
- * will be appended to the object. Otherwise,
+Tcl_ReadChars(
+ Tcl_Channel chan, /* The channel to read. */
+ Tcl_Obj *objPtr, /* Input data is stored in this object. */
+ int toRead, /* Maximum number of characters to store, or
+ * -1 to read all available data (up to EOF or
+ * when channel blocks). */
+ int appendFlag) /* If non-zero, data read from the channel
+ * will be appended to the object. Otherwise,
* the data will replace the existing contents
* of the object. */
-
{
- Channel* chanPtr = (Channel *) chan;
- ChannelState* statePtr = chanPtr->state; /* state info for channel */
-
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+
/*
* This operation should occur at the top of a channel stack.
*/
@@ -4453,52 +5173,53 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
chanPtr = statePtr->topChanPtr;
if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
- /*
+ /*
* Update the notifier state so we don't block while there is still
* data in the buffers.
*/
- UpdateInterest(chanPtr);
+
+ UpdateInterest(chanPtr);
return -1;
}
- return DoReadChars (chanPtr, objPtr, toRead, appendFlag);
+ return DoReadChars(chanPtr, objPtr, toRead, appendFlag);
}
/*
*---------------------------------------------------------------------------
*
* DoReadChars --
*
- * Reads from the channel until the requested number of characters
- * have been seen, EOF is seen, or the channel would block. EOL
- * and EOF translation is done. If reading binary data, the raw
- * bytes are wrapped in a Tcl byte array object. Otherwise, the raw
- * bytes are converted to UTF-8 using the channel's current encoding
- * and stored in a Tcl string object.
+ * Reads from the channel until the requested number of characters have
+ * been seen, EOF is seen, or the channel would block. EOL and EOF
+ * translation is done. If reading binary data, the raw bytes are wrapped
+ * in a Tcl byte array object. Otherwise, the raw bytes are converted to
+ * UTF-8 using the channel's current encoding and stored in a Tcl string
+ * object.
*
* Results:
- * The number of characters read, or -1 on error. Use Tcl_GetErrno()
- * to retrieve the error code for the error that occurred.
+ * The number of characters read, or -1 on error. Use Tcl_GetErrno() to
+ * retrieve the error code for the error that occurred.
*
* Side effects:
* May cause input to be buffered.
*
*---------------------------------------------------------------------------
*/
-
+
static int
-DoReadChars(chanPtr, objPtr, toRead, appendFlag)
- Channel* chanPtr; /* The channel to read. */
- Tcl_Obj *objPtr; /* Input data is stored in this object. */
- int toRead; /* Maximum number of characters to store,
- * or -1 to read all available data (up to EOF
- * or when channel blocks). */
- int appendFlag; /* If non-zero, data read from the channel
- * will be appended to the object. Otherwise,
+DoReadChars(
+ Channel *chanPtr, /* The channel to read. */
+ Tcl_Obj *objPtr, /* Input data is stored in this object. */
+ int toRead, /* Maximum number of characters to store, or
+ * -1 to read all available data (up to EOF or
+ * when channel blocks). */
+ int appendFlag) /* If non-zero, data read from the channel
+ * will be appended to the object. Otherwise,
* the data will replace the existing contents
* of the object. */
-
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
int offset, factor, copied, copiedNow, result;
Tcl_Encoding encoding;
@@ -4508,28 +5229,30 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
* This operation should occur at the top of a channel stack.
*/
- chanPtr = statePtr->topChanPtr;
+ chanPtr = statePtr->topChanPtr;
encoding = statePtr->encoding;
- factor = UTF_EXPANSION_FACTOR;
+ factor = UTF_EXPANSION_FACTOR;
if (appendFlag == 0) {
if (encoding == NULL) {
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);
+
+ TclGetString(objPtr);
}
offset = 0;
} else {
if (encoding == NULL) {
Tcl_GetByteArrayFromObj(objPtr, &offset);
} else {
- Tcl_GetStringFromObj(objPtr, &offset);
+ TclGetStringFromObj(objPtr, &offset);
}
}
@@ -4548,7 +5271,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
*/
bufPtr = statePtr->inQueueHead;
- if (bufPtr->nextRemoved == bufPtr->nextAdded) {
+ if (IsBufferEmpty(bufPtr)) {
ChannelBuffer *nextPtr;
nextPtr = bufPtr->nextPtr;
@@ -4559,6 +5282,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
}
}
}
+
if (copiedNow < 0) {
if (statePtr->flags & CHANNEL_EOF) {
break;
@@ -4567,7 +5291,7 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
if (statePtr->flags & CHANNEL_NONBLOCKING) {
break;
}
- statePtr->flags &= ~CHANNEL_BLOCKED;
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
}
result = GetInput(chanPtr);
if (result != 0) {
@@ -4582,41 +5306,42 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
toRead -= copiedNow;
}
}
- statePtr->flags &= ~CHANNEL_BLOCKED;
+
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
if (encoding == NULL) {
Tcl_SetByteArrayLength(objPtr, offset);
} else {
Tcl_SetObjLength(objPtr, offset);
}
- done:
/*
- * Update the notifier state so we don't block while there is still
- * data in the buffers.
+ * Update the notifier state so we don't block while there is still data
+ * in the buffers.
*/
+ done:
UpdateInterest(chanPtr);
return copied;
}
+
/*
*---------------------------------------------------------------------------
*
* ReadBytes --
*
- * Reads from the channel until the requested number of bytes have
- * been seen, EOF is seen, or the channel would block. Bytes from
- * the channel are stored in objPtr as a ByteArray object. EOL
- * and EOF translation are done.
+ * Reads from the channel until the requested number of bytes have been
+ * seen, EOF is seen, or the channel would block. Bytes from the channel
+ * are stored in objPtr as a ByteArray object. EOL and EOF translation
+ * are done.
*
- * 'bytesToRead' can safely be a very large number because
- * space is only allocated to hold data read from the channel
- * as needed.
+ * 'bytesToRead' can safely be a very large number because space is only
+ * allocated to hold data read from the channel as needed.
*
* Results:
- * The return value is the number of bytes appended to the object
- * and *offsetPtr is filled with the total number of bytes in the
- * object (greater than the return value if there were already bytes
- * in the object).
+ * The return value is the number of bytes appended to the object and
+ * *offsetPtr is filled with the total number of bytes in the object
+ * (greater than the return value if there were already bytes in the
+ * object).
*
* Side effects:
* None.
@@ -4625,25 +5350,24 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
*/
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
+ReadBytes(
+ ChannelState *statePtr, /* State of the channel to read. */
+ Tcl_Obj *objPtr, /* Input data is appended to this ByteArray
+ * object. Its length is how much space has
+ * been allocated to hold data, not how many
+ * bytes of data have been stored in the
* 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;
@@ -4651,9 +5375,9 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
offset = *offsetPtr;
- bufPtr = statePtr->inQueueHead;
- src = bufPtr->buf + bufPtr->nextRemoved;
- srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
+ bufPtr = statePtr->inQueueHead;
+ src = RemovePoint(bufPtr);
+ srcLen = BytesLeft(bufPtr);
toRead = bytesToRead;
if ((unsigned) toRead > (unsigned) srcLen) {
@@ -4663,9 +5387,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;
@@ -4677,7 +5401,7 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
dst += offset;
if (statePtr->flags & INPUT_NEED_NL) {
- statePtr->flags &= ~INPUT_NEED_NL;
+ ResetFlag(statePtr, INPUT_NEED_NL);
if ((srcLen == 0) || (*src != '\n')) {
*dst = '\r';
*offsetPtr += 1;
@@ -4706,21 +5430,21 @@ 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.
+ * 'charsToRead' may *not* be 0.
*
* 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.
@@ -4729,31 +5453,31 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
*/
static int
-ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
- ChannelState *statePtr; /* State of channel to read. */
- Tcl_Obj *objPtr; /* Input data is appended to this object.
+ReadChars(
+ ChannelState *statePtr, /* State of channel to read. */
+ Tcl_Obj *objPtr, /* Input data is appended to this object.
* objPtr->length is how much space has been
* allocated to hold data, not how many bytes
* of data have been stored in the object. */
- int charsToRead; /* Maximum number of characters to store,
- * or -1 to get all available characters.
+ int charsToRead, /* Maximum number of characters to store, or
+ * -1 to get all available characters.
* Characters are obtained from the first
* buffer in the queue -- even if this number
* is larger than the number of characters
* available in the first buffer, only the
* characters from the first buffer are
* returned. */
- int *offsetPtr; /* On input, contains how many bytes of
- * objPtr have been used to hold data. On
- * output, filled with how many bytes are now
- * being used. */
- int *factorPtr; /* On input, contains a guess of how many
+ int *offsetPtr, /* On input, contains how many bytes of objPtr
+ * have been used to hold data. On output,
+ * filled with how many bytes are now being
+ * used. */
+ int *factorPtr) /* On input, contains a guess of how many
* bytes need to be allocated to hold the
* result of converting N source bytes to
- * UTF-8. On output, contains another guess
+ * UTF-8. On output, contains another guess
* based on the data seen so far. */
{
- int toRead, factor, offset, spaceLeft, length, srcLen, dstNeeded;
+ int toRead, factor, offset, spaceLeft, srcLen, dstNeeded;
int srcRead, dstWrote, numChars, dstRead;
ChannelBuffer *bufPtr;
char *src, *dst;
@@ -4763,9 +5487,9 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
factor = *factorPtr;
offset = *offsetPtr;
- bufPtr = statePtr->inQueueHead;
- src = bufPtr->buf + bufPtr->nextRemoved;
- srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
+ bufPtr = statePtr->inQueueHead;
+ src = RemovePoint(bufPtr);
+ srcLen = BytesLeft(bufPtr);
toRead = charsToRead;
if ((unsigned)toRead > (unsigned)srcLen) {
@@ -4773,35 +5497,38 @@ 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;
- spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1;
+ dstNeeded = TCL_UTF_MAX - 1 + toRead * factor / UTF_EXPANSION_FACTOR;
+ spaceLeft = objPtr->length - offset;
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;
- if (offset < dstNeeded) {
+ int length = offset + ((offset < dstNeeded) ? dstNeeded : offset);
+
+ if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
length = offset + dstNeeded;
+ if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
+ dstNeeded = TCL_UTF_MAX - 1 + toRead;
+ length = offset + dstNeeded;
+ Tcl_SetObjLength(objPtr, length);
+ }
}
spaceLeft = length - offset;
- length += TCL_UTF_MAX + 1;
- Tcl_SetObjLength(objPtr, length);
}
if (toRead == srcLen) {
/*
- * Want to convert the whole buffer in one pass. If we have
- * enough space, convert it using all available space in object
- * rather than using the factor.
+ * Want to convert the whole buffer in one pass. If we have enough
+ * space, convert it using all available space in object rather than
+ * using the factor.
*/
dstNeeded = spaceLeft;
@@ -4809,51 +5536,48 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
dst = objPtr->bytes + offset;
/*
- * SF Tcl Bug 1462248
- * The cause of the crash reported in the referenced bug is this:
+ * [Bug 1462248]: The cause of the crash reported in this bug is this:
*
* - ReadChars, called with a single buffer, with a incomplete
- * multi-byte character at the end (only the first byte of it).
+ * multi-byte character at the end (only the first byte of it).
* - Encoding translation fails, asks for more data
* - Data is read, and eof is reached, TCL_ENCODING_END (TEE) is set.
- * - ReadChar is called again, converts the first buffer, but due
- * to TEE it does not check for incomplete multi-byte data, and the
- * character just after the end of the first buffer is a valid
- * completion of the multi-byte header in the actual buffer. The
- * conversion reads more characters from the buffer then present.
- * This causes nextRemoved to overshoot nextAdded and the next
- * reads compute a negative srcLen, cause further translations to
- * fail, causing copying of data into the next buffer using bad
- * arguments, causing the mecpy for to eventually fail.
+ * - ReadChar is called again, converts the first buffer, but due to TEE
+ * it does not check for incomplete multi-byte data, and the character
+ * just after the end of the first buffer is a valid completion of the
+ * multi-byte header in the actual buffer. The conversion reads more
+ * characters from the buffer then present. This causes nextRemoved to
+ * overshoot nextAdded and the next reads compute a negative srcLen,
+ * cause further translations to fail, causing copying of data into the
+ * next buffer using bad arguments, causing the mecpy for to eventually
+ * fail.
*
- * In the end it is a memory access bug spiraling out of control
- * if the conditions are _just so_. And ultimate cause is that TEE
- * is given to a conversion where it should not. TEE signals that
- * this is the last buffer. Except in our case it is not.
+ * In the end it is a memory access bug spiraling out of control if the
+ * conditions are _just so_. And ultimate cause is that TEE is given to a
+ * conversion where it should not. TEE signals that this is the last
+ * buffer. Except in our case it is not.
*
- * My solution is to suppress TEE if the first buffer is not the
- * last. We will eventually need it given that EOF has been
- * reached, but not right now. This is what the new flag
- * "endEncSuppressFlag" is for.
+ * My solution is to suppress TEE if the first buffer is not the last. We
+ * will eventually need it given that EOF has been reached, but not right
+ * now. This is what the new flag "endEncSuppressFlag" is for.
*
- * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind
- * the actual buffer has been fixed as well, and fixes the problem
- * with the crash too, but this would still allow the generic
- * layer to accidentially break a multi-byte sequence if the
- * conditions are just right, because again the ExternalToUtf
- * would be successful where it should not.
+ * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind the
+ * actual buffer has been fixed as well, and fixes the problem with the
+ * crash too, but this would still allow the generic layer to
+ * accidentially break a multi-byte sequence if the conditions are just
+ * right, because again the ExternalToUtf would be successful where it
+ * should not.
*/
if ((statePtr->inputEncodingFlags & TCL_ENCODING_END) &&
- (bufPtr->nextPtr != NULL)) {
-
- /* TEE is set for a buffer which is not the last. Squash it
- * for now, and restore it later, before yielding control to
- * our caller.
+ (bufPtr->nextPtr != NULL)) {
+ /*
+ * TEE is set for a buffer which is not the last. Squash it for now,
+ * and restore it later, before yielding control to our caller.
*/
- statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
- encEndFlagSuppressed = 1;
+ statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+ encEndFlagSuppressed = 1;
}
oldState = statePtr->inputEncodingState;
@@ -4862,19 +5586,19 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
* We want a '\n' because the last character we saw was '\r'.
*/
- statePtr->flags &= ~INPUT_NEED_NL;
+ ResetFlag(statePtr, INPUT_NEED_NL);
Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars);
if ((dstWrote > 0) && (*dst == '\n')) {
/*
- * The next char was a '\n'. Consume it and produce a '\n'.
+ * The next char was a '\n'. Consume it and produce a '\n'.
*/
bufPtr->nextRemoved += srcRead;
} else {
/*
- * The next char was not a '\n'. Produce a '\r'.
+ * The next char was not a '\n'. Produce a '\r'.
*/
*dst = '\r';
@@ -4885,67 +5609,64 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
if (encEndFlagSuppressed) {
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
}
- return 1;
+ return 1;
}
Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst,
- dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
+ dstNeeded + 1, &srcRead, &dstWrote, &numChars);
if (encEndFlagSuppressed) {
- statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
}
if (srcRead == 0) {
/*
- * Not enough bytes in src buffer to make a complete char. Copy
- * the bytes to the next buffer to make a new contiguous string,
- * then tell the caller to fill the buffer with more bytes.
+ * Not enough bytes in src buffer to make a complete char. Copy the
+ * bytes to the next buffer to make a new contiguous string, then tell
+ * the caller to fill the buffer with more bytes.
*/
ChannelBuffer *nextPtr;
-
+
nextPtr = bufPtr->nextPtr;
if (nextPtr == NULL) {
if (srcLen > 0) {
- /*
+ /*
* There isn't enough data in the buffers to complete the next
* character, so we need to wait for more data before the next
- * file event can be delivered.
+ * file event can be delivered. [Bug 478856]
*
- * 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;
+ SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
}
return -1;
}
- /* Space is made at the beginning of the buffer to copy the
- * previous unused bytes there. Check first if the buffer we
- * are using actually has enough space at its beginning for
- * the data we are copying. Because if not we will write over the
- * buffer management information, especially the 'nextPtr'.
+ /*
+ * Space is made at the beginning of the buffer to copy the previous
+ * unused bytes there. Check first if the buffer we are using actually
+ * has enough space at its beginning for the data we are copying.
+ * Because if not we will write over the buffer management
+ * information, especially the 'nextPtr'.
*
- * Note that the BUFFER_PADDING (See AllocChannelBuffer) is
- * used to prevent exactly this situation. I.e. it should
- * never happen. Therefore it is ok to panic should it happen
- * despite the precautions.
+ * Note that the BUFFER_PADDING (See AllocChannelBuffer) is used to
+ * prevent exactly this situation. I.e. it should never happen.
+ * Therefore it is ok to panic should it happen despite the
+ * precautions.
*/
if (nextPtr->nextRemoved - srcLen < 0) {
- Tcl_Panic ("Buffer Underflow, BUFFER_PADDING not enough");
+ Tcl_Panic("Buffer Underflow, BUFFER_PADDING not enough");
}
nextPtr->nextRemoved -= srcLen;
- memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src,
- (size_t) srcLen);
+ memcpy(RemovePoint(nextPtr), src, (size_t) srcLen);
RecycleBuffer(statePtr, bufPtr, 0);
statePtr->inQueueHead = nextPtr;
return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
@@ -4954,12 +5675,12 @@ 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) {
return -1;
}
@@ -4968,12 +5689,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);
@@ -4983,7 +5704,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
* Got too many chars.
*/
- CONST char *eof;
+ const char *eof;
eof = Tcl_UtfAtIndex(dst, toRead);
statePtr->inputEncodingState = oldState;
@@ -5009,12 +5730,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.
@@ -5023,23 +5744,23 @@ 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. */
- CONST char *srcStart; /* Source characters. */
- int *dstLenPtr; /* On entry, the maximum length of output
- * buffer in bytes; must be <= *srcLenPtr. On
+TranslateInputEOL(
+ ChannelState *statePtr, /* Channel being read, for EOL translation and
+ * EOF character. */
+ char *dstStart, /* Output buffer filled with chars by applying
+ * appropriate EOL translation to source
+ * characters. */
+ const char *srcStart, /* Source characters. */
+ int *dstLenPtr, /* On entry, the maximum length of output
+ * buffer in bytes; must be <= *srcLenPtr. On
* exit, the number of bytes actually used in
* output buffer. */
- int *srcLenPtr; /* On entry, the length of source buffer.
- * On exit, the number of bytes read from
- * the source buffer. */
+ int *srcLenPtr) /* On entry, the length of source buffer. On
+ * exit, the number of bytes read from the
+ * source buffer. */
{
int dstLen, srcLen, inEofChar;
- CONST char *eof;
+ const char *eof;
dstLen = *dstLenPtr;
@@ -5047,13 +5768,13 @@ 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;
+ const char *src, *srcMax;
srcMax = srcStart + *srcLenPtr;
for (src = srcStart; src < srcMax; src++) {
@@ -5069,106 +5790,104 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
}
}
switch (statePtr->inputTranslation) {
- case TCL_TRANSLATE_LF: {
- if (dstStart != srcStart) {
- memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
+ case TCL_TRANSLATE_LF:
+ if (dstStart != srcStart) {
+ memcpy(dstStart, srcStart, (size_t) dstLen);
+ }
+ srcLen = dstLen;
+ break;
+ case TCL_TRANSLATE_CR: {
+ char *dst, *dstEnd;
+
+ if (dstStart != srcStart) {
+ memcpy(dstStart, srcStart, (size_t) dstLen);
+ }
+ dstEnd = dstStart + dstLen;
+ for (dst = dstStart; dst < dstEnd; dst++) {
+ if (*dst == '\r') {
+ *dst = '\n';
}
- 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';
- }
- }
- srcLen = dstLen;
- break;
- }
- case TCL_TRANSLATE_CRLF: {
- char *dst;
- CONST char *src, *srcEnd, *srcMax;
-
- dst = dstStart;
- src = srcStart;
- srcEnd = srcStart + dstLen;
- srcMax = srcStart + *srcLenPtr;
-
- for ( ; src < srcEnd; ) {
- if (*src == '\r') {
- src++;
- if (src >= srcMax) {
- statePtr->flags |= INPUT_NEED_NL;
- } else if (*src == '\n') {
- *dst++ = *src++;
- } else {
- *dst++ = '\r';
- }
- } else {
+ srcLen = dstLen;
+ break;
+ }
+ case TCL_TRANSLATE_CRLF: {
+ char *dst;
+ const char *src, *srcEnd, *srcMax;
+
+ dst = dstStart;
+ src = srcStart;
+ srcEnd = srcStart + dstLen;
+ srcMax = srcStart + *srcLenPtr;
+
+ for ( ; src < srcEnd; ) {
+ if (*src == '\r') {
+ src++;
+ if (src >= srcMax) {
+ SetFlag(statePtr, INPUT_NEED_NL);
+ } else if (*src == '\n') {
*dst++ = *src++;
+ } 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++;
+ ResetFlag(statePtr, INPUT_SAW_CR);
+ }
+ for ( ; src < srcEnd; ) {
+ if (*src == '\r') {
+ src++;
+ if (src >= srcMax) {
+ SetFlag(statePtr, INPUT_SAW_CR);
+ } else if (*src == '\n') {
+ if (srcEnd < srcMax) {
+ srcEnd++;
}
- *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);
+ SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
- statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
+ ResetFlag(statePtr, INPUT_SAW_CR | INPUT_NEED_NL);
return 1;
}
@@ -5181,8 +5900,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.
@@ -5194,17 +5913,17 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
*/
int
-Tcl_Ungets(chan, str, len, atEnd)
- Tcl_Channel chan; /* The channel for which to add the input. */
- CONST char *str; /* The input itself. */
- int len; /* The length of the input. */
- int atEnd; /* If non-zero, add at end of queue; otherwise
- * add at head of queue. */
+Tcl_Ungets(
+ Tcl_Channel chan, /* The channel for which to add the input. */
+ const char *str, /* The input itself. */
+ int len, /* The length of the input. */
+ int atEnd) /* If non-zero, add at end of queue; otherwise
+ * add at head of queue. */
{
Channel *chanPtr; /* The real IO channel. */
ChannelState *statePtr; /* State of actual channel. */
ChannelBuffer *bufPtr; /* Buffer to contain the data. */
- int i, flags;
+ int flags;
chanPtr = (Channel *) chan;
statePtr = chanPtr->state;
@@ -5218,7 +5937,7 @@ Tcl_Ungets(chan, str, len, atEnd)
/*
* CheckChannelErrors clears too many flag bits in this one case.
*/
-
+
flags = statePtr->flags;
if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
len = -1;
@@ -5227,42 +5946,40 @@ 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) {
goto done;
}
- statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
+ ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_EOF);
bufPtr = AllocChannelBuffer(len);
- for (i = 0; i < len; i++) {
- bufPtr->buf[bufPtr->nextAdded++] = str[i];
- }
+ memcpy(InsertPoint(bufPtr), str, (size_t) len);
+ bufPtr->nextAdded += len;
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
- statePtr->inQueueHead = bufPtr;
- statePtr->inQueueTail = bufPtr;
+ if (statePtr->inQueueHead == NULL) {
+ bufPtr->nextPtr = NULL;
+ statePtr->inQueueHead = bufPtr;
+ statePtr->inQueueTail = bufPtr;
} else if (atEnd) {
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
- statePtr->inQueueTail->nextPtr = bufPtr;
- statePtr->inQueueTail = bufPtr;
+ bufPtr->nextPtr = NULL;
+ statePtr->inQueueTail->nextPtr = bufPtr;
+ statePtr->inQueueTail = bufPtr;
} else {
- bufPtr->nextPtr = statePtr->inQueueHead;
- statePtr->inQueueHead = bufPtr;
+ bufPtr->nextPtr = statePtr->inQueueHead;
+ statePtr->inQueueHead = bufPtr;
}
- done:
/*
- * Update the notifier state so we don't block while there is still
- * data in the buffers.
+ * Update the notifier state so we don't block while there is still data
+ * in the buffers.
*/
+ done:
UpdateInterest(chanPtr);
return len;
}
@@ -5284,12 +6001,14 @@ Tcl_Ungets(chan, str, len, atEnd)
*/
int
-Tcl_Flush(chan)
- Tcl_Channel chan; /* The Channel to flush. */
+Tcl_Flush(
+ Tcl_Channel chan) /* The Channel to flush. */
{
- int result; /* Of calling FlushChannel. */
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
- ChannelState *statePtr = chanPtr->state; /* State of actual channel. */
+ int result; /* Of calling FlushChannel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State of actual channel. */
/*
* This operation should occur at the top of a channel stack.
@@ -5305,14 +6024,13 @@ Tcl_Flush(chan)
* Force current output buffer to be output also.
*/
- if ((statePtr->curOutPtr != NULL)
- && (statePtr->curOutPtr->nextAdded > 0)) {
- statePtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
}
-
+
result = FlushChannel(NULL, chanPtr, 0);
if (result != 0) {
- return TCL_ERROR;
+ return TCL_ERROR;
}
return TCL_OK;
@@ -5323,8 +6041,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.
@@ -5337,32 +6055,31 @@ Tcl_Flush(chan)
*/
static void
-DiscardInputQueued(statePtr, discardSavedBuffers)
- ChannelState *statePtr; /* Channel on which to discard
- * the queued input. */
- int discardSavedBuffers; /* If non-zero, discard all buffers including
- * last one. */
+DiscardInputQueued(
+ ChannelState *statePtr, /* Channel on which to discard the queued
+ * input. */
+ int discardSavedBuffers) /* If non-zero, discard all buffers including
+ * last one. */
{
- ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
+ ChannelBuffer *bufPtr, *nxtPtr;
+ /* Loop variables. */
bufPtr = statePtr->inQueueHead;
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
- for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
- nxtPtr = bufPtr->nextPtr;
- RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
+ for (; bufPtr != NULL; bufPtr = nxtPtr) {
+ nxtPtr = bufPtr->nextPtr;
+ RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
}
/*
* If discardSavedBuffers is nonzero, must also discard any previously
* saved buffer in the saveInBufPtr field.
*/
-
- if (discardSavedBuffers) {
- if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) {
- ckfree((char *) statePtr->saveInBufPtr);
- statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
- }
+
+ if (discardSavedBuffers && statePtr->saveInBufPtr != NULL) {
+ ckfree((char *) statePtr->saveInBufPtr);
+ statePtr->saveInBufPtr = NULL;
}
}
@@ -5371,11 +6088,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.
@@ -5384,14 +6101,15 @@ DiscardInputQueued(statePtr, discardSavedBuffers)
*/
static int
-GetInput(chanPtr)
- Channel *chanPtr; /* Channel to read input from. */
+GetInput(
+ Channel *chanPtr) /* Channel to read input from. */
{
int toRead; /* How much to read? */
int result; /* Of calling driver. */
int nread; /* How much was read from channel? */
ChannelBuffer *bufPtr; /* New buffer to add to input queue. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* Prevent reading from a dead channel -- a channel that has been closed
@@ -5399,90 +6117,91 @@ GetInput(chanPtr)
* channel cleanup has run but the channel is still registered in some
* interpreter.
*/
-
+
if (CheckForDeadChannel(NULL, statePtr)) {
return EINVAL;
}
/*
- * First check for more buffers in the pushback area of the
- * topmost channel in the stack and use them. They can be the
- * result of a transformation which went away without reading all
- * the information placed in the area when it was stacked.
+ * First check for more buffers in the pushback area of the topmost
+ * channel in the stack and use them. They can be the result of a
+ * transformation which went away without reading all the information
+ * placed in the area when it was stacked.
*
- * Two possibilities for the state: No buffers in it, or a single
- * empty buffer. In the latter case we can recycle it now.
+ * Two possibilities for the state: No buffers in it, or a single empty
+ * buffer. In the latter case we can recycle it now.
*/
- if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
- if (statePtr->inQueueHead != (ChannelBuffer*) NULL) {
+ if (chanPtr->inQueueHead != NULL) {
+ if (statePtr->inQueueHead != NULL) {
RecycleBuffer(statePtr, statePtr->inQueueHead, 0);
- statePtr->inQueueHead = (ChannelBuffer*) NULL;
+ statePtr->inQueueHead = NULL;
}
statePtr->inQueueHead = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
- chanPtr->inQueueHead = (ChannelBuffer*) NULL;
- chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
return 0;
}
/*
- * Nothing in the pushback area, fall back to the usual handling
- * (driver, etc.)
+ * Nothing in the pushback area, fall back to the usual handling (driver,
+ * etc.)
*/
/*
- * See if we can fill an existing buffer. If we can, read only
- * as much as will fit in it. Otherwise allocate a new buffer,
- * add it to the input queue and attempt to fill it to the max.
+ * See if we can fill an existing buffer. If we can, read only as much as
+ * will fit in it. Otherwise allocate a new buffer, add it to the input
+ * queue and attempt to fill it to the max.
*/
bufPtr = statePtr->inQueueTail;
- if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) {
- toRead = bufPtr->bufLength - bufPtr->nextAdded;
+ if ((bufPtr != NULL) && !IsBufferFull(bufPtr)) {
+ toRead = SpaceLeft(bufPtr);
} else {
bufPtr = statePtr->saveInBufPtr;
statePtr->saveInBufPtr = NULL;
/*
- * Check the actual buffersize against the requested
- * buffersize. Buffers which are smaller than requested are
- * squashed. This is done to honor dynamic changes of the
- * buffersize made by the user.
+ * Check the actual buffersize against the requested buffersize.
+ * Buffers which are smaller than requested are squashed. This is done
+ * to honor dynamic changes of the buffersize made by the user.
*/
- if ((bufPtr != NULL) && ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize)) {
- ckfree((char *) bufPtr);
- bufPtr = NULL;
+ if ((bufPtr != NULL)
+ && (bufPtr->bufLength - BUFFER_PADDING < statePtr->bufSize)) {
+ ckfree((char *) bufPtr);
+ bufPtr = NULL;
}
if (bufPtr == NULL) {
bufPtr = AllocChannelBuffer(statePtr->bufSize);
}
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = 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;
+ toRead = SpaceLeft(bufPtr);
- if (statePtr->inQueueTail == NULL) {
- statePtr->inQueueHead = bufPtr;
- } else {
- statePtr->inQueueTail->nextPtr = bufPtr;
- }
- statePtr->inQueueTail = bufPtr;
+ if (statePtr->inQueueTail == NULL) {
+ statePtr->inQueueHead = bufPtr;
+ } else {
+ statePtr->inQueueTail->nextPtr = bufPtr;
+ }
+ statePtr->inQueueTail = bufPtr;
}
/*
@@ -5495,24 +6214,27 @@ 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) &&
- (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
- !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
+ (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
+ !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
+ /*
+ * Bypass the driver, it would block, as no data is available
+ */
- /* Bypass the driver, it would block, as no data is available */
- nread = -1;
- result = EWOULDBLOCK;
+ nread = -1;
+ result = EWOULDBLOCK;
} else {
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
- nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
- bufPtr->buf + bufPtr->nextAdded, toRead, &result);
+ nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+ InsertPoint(bufPtr), toRead, &result);
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
}
@@ -5522,30 +6244,33 @@ 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) {
- statePtr->flags |= CHANNEL_BLOCKED;
+ SetFlag(statePtr, CHANNEL_BLOCKED);
}
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
if (nread <= toRead) {
- /* [SF Tcl Bug 943274] We have read the available data,
- * clear flag */
- statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
+ /*
+ * [SF Tcl Bug 943274] We have read the available data, clear
+ * flag.
+ */
+
+ ResetFlag(statePtr, CHANNEL_HAS_MORE_DATA);
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
} else if (nread == 0) {
- statePtr->flags |= CHANNEL_EOF;
+ SetFlag(statePtr, CHANNEL_EOF);
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
} else if (nread < 0) {
if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
- statePtr->flags |= CHANNEL_BLOCKED;
+ SetFlag(statePtr, CHANNEL_BLOCKED);
result = EAGAIN;
}
Tcl_SetErrno(result);
@@ -5559,12 +6284,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.
@@ -5573,30 +6298,32 @@ GetInput(chanPtr)
*/
Tcl_WideInt
-Tcl_Seek(chan, offset, mode)
- Tcl_Channel chan; /* The channel on which to seek. */
- Tcl_WideInt offset; /* Offset to seek to. */
- int mode; /* Relative to which location to seek? */
+Tcl_Seek(
+ Tcl_Channel chan, /* The channel on which to seek. */
+ Tcl_WideInt offset, /* Offset to seek to. */
+ int mode) /* Relative to which location to seek? */
{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int inputBuffered, outputBuffered;
/* # bytes held in buffers. */
int result; /* Of device driver operations. */
Tcl_WideInt curPos; /* Position on the device. */
- int wasAsync; /* Was the channel nonblocking before the
- * seek operation? If so, must restore to
- * 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)) {
@@ -5614,22 +6341,22 @@ Tcl_Seek(chan, offset, mode)
* defined. This means that the channel does not support seeking.
*/
- if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
- Tcl_SetErrno(EINVAL);
- return Tcl_LongAsWide(-1);
+ if (chanPtr->typePtr->seekProc == NULL) {
+ Tcl_SetErrno(EINVAL);
+ return Tcl_LongAsWide(-1);
}
/*
- * Compute how much input and output is buffered. If both input and
- * output is buffered, cannot compute the current position.
+ * Compute how much input and output is buffered. If both input and output
+ * is buffered, cannot compute the current position.
*/
inputBuffered = Tcl_InputBuffered(chan);
outputBuffered = Tcl_OutputBuffered(chan);
if ((inputBuffered != 0) && (outputBuffered != 0)) {
- Tcl_SetErrno(EFAULT);
- return Tcl_LongAsWide(-1);
+ Tcl_SetErrno(EFAULT);
+ return Tcl_LongAsWide(-1);
}
/*
@@ -5638,61 +6365,69 @@ Tcl_Seek(chan, offset, mode)
*/
if (mode == SEEK_CUR) {
- offset -= inputBuffered;
+ offset -= inputBuffered;
}
/*
- * Discard any queued input - this input should not be read after
- * the seek.
+ * Discard any queued input - this input should not be read after the
+ * seek.
*/
DiscardInputQueued(statePtr, 0);
/*
- * Reset EOF and BLOCKED flags. We invalidate them by moving the
- * access point. Also clear CR related flags.
+ * Reset EOF and BLOCKED flags. We invalidate them by moving the access
+ * point. Also clear CR related flags.
*/
statePtr->flags &=
- (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR));
-
+ ~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR);
+
/*
- * If the channel is in asynchronous output mode, switch it back
- * to synchronous mode and cancel any async flush that may be
- * scheduled. After the flush, the channel will be put back into
- * asynchronous output mode.
+ * If the channel is in asynchronous output mode, switch it back to
+ * synchronous mode and cancel any async flush that may be scheduled.
+ * After the flush, the channel will be put back into asynchronous output
+ * mode.
*/
wasAsync = 0;
if (statePtr->flags & CHANNEL_NONBLOCKING) {
- wasAsync = 1;
- result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
+ wasAsync = 1;
+ result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
if (result != 0) {
return Tcl_LongAsWide(-1);
}
- statePtr->flags &= (~(CHANNEL_NONBLOCKING));
- if (statePtr->flags & BG_FLUSH_SCHEDULED) {
- statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
- }
+ ResetFlag(statePtr, CHANNEL_NONBLOCKING);
+ if (statePtr->flags & BG_FLUSH_SCHEDULED) {
+ ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
+ }
}
-
+
+ /*
+ * If there is data buffered in statePtr->curOutPtr then mark the channel
+ * as ready to flush before invoking FlushChannel.
+ */
+
+ if ((statePtr->curOutPtr != NULL) && IsBufferReady(statePtr->curOutPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
+ }
+
/*
- * If the flush fails we cannot recover the original position. In
- * that case the seek is not attempted because we do not know where
- * the access position is - instead we return the error. FlushChannel
- * has already called Tcl_SetErrno() to report the error upwards.
- * If the flush succeeds we do the seek also.
+ * If the flush fails we cannot recover the original position. In that
+ * case the seek is not attempted because we do not know where the access
+ * position is - instead we return the error. FlushChannel has already
+ * called Tcl_SetErrno() to report the error upwards. If the flush
+ * succeeds we do the seek also.
*/
-
+
if (FlushChannel(NULL, chanPtr, 0) != 0) {
- curPos = -1;
+ curPos = -1;
} else {
-
- /*
- * Now seek to the new position in the channel as requested by the
- * caller. Note that we prefer the wideSeekProc if that is
- * available and non-NULL...
- */
+ /*
+ * Now seek to the new position in the channel as requested by the
+ * caller. Note that we prefer the wideSeekProc if that is available
+ * and non-NULL...
+ */
if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) &&
chanPtr->typePtr->wideSeekProc != NULL) {
@@ -5711,17 +6446,17 @@ Tcl_Seek(chan, offset, mode)
Tcl_SetErrno(result);
}
}
-
+
/*
* Restore to nonblocking mode if that was the previous behavior.
*
- * NOTE: Even if there was an async flush active we do not restore
- * it now because we already flushed all the queued output, above.
+ * NOTE: Even if there was an async flush active we do not restore it now
+ * because we already flushed all the queued output, above.
*/
-
+
if (wasAsync) {
- statePtr->flags |= CHANNEL_NONBLOCKING;
- result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
+ SetFlag(statePtr, CHANNEL_NONBLOCKING);
+ result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
if (result != 0) {
return Tcl_LongAsWide(-1);
}
@@ -5735,13 +6470,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.
@@ -5750,14 +6485,17 @@ Tcl_Seek(chan, offset, mode)
*/
Tcl_WideInt
-Tcl_Tell(chan)
- Tcl_Channel chan; /* The channel to return pos for. */
+Tcl_Tell(
+ Tcl_Channel chan) /* The channel to return pos for. */
{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
- int inputBuffered, outputBuffered; /* # bytes held in buffers. */
- int result; /* Of calling device driver. */
- Tcl_WideInt curPos; /* Position on device. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ int inputBuffered, outputBuffered;
+ /* # bytes held in buffers. */
+ int result; /* Of calling device driver. */
+ Tcl_WideInt curPos; /* Position on device. */
if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
return Tcl_LongAsWide(-1);
@@ -5766,8 +6504,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)) {
@@ -5785,28 +6523,28 @@ Tcl_Tell(chan)
* defined. This means that the channel does not support seeking.
*/
- if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
- Tcl_SetErrno(EINVAL);
- return Tcl_LongAsWide(-1);
+ if (chanPtr->typePtr->seekProc == NULL) {
+ Tcl_SetErrno(EINVAL);
+ return Tcl_LongAsWide(-1);
}
/*
- * Compute how much input and output is buffered. If both input and
- * output is buffered, cannot compute the current position.
+ * Compute how much input and output is buffered. If both input and output
+ * is buffered, cannot compute the current position.
*/
inputBuffered = Tcl_InputBuffered(chan);
outputBuffered = Tcl_OutputBuffered(chan);
if ((inputBuffered != 0) && (outputBuffered != 0)) {
- Tcl_SetErrno(EFAULT);
- return Tcl_LongAsWide(-1);
+ Tcl_SetErrno(EFAULT);
+ return Tcl_LongAsWide(-1);
}
/*
- * 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) &&
@@ -5818,11 +6556,11 @@ Tcl_Tell(chan)
chanPtr->instanceData, 0, SEEK_CUR, &result));
}
if (curPos == Tcl_LongAsWide(-1)) {
- Tcl_SetErrno(result);
- return Tcl_LongAsWide(-1);
+ Tcl_SetErrno(result);
+ return Tcl_LongAsWide(-1);
}
if (inputBuffered != 0) {
- return curPos - inputBuffered;
+ return curPos - inputBuffered;
}
return curPos + outputBuffered;
}
@@ -5832,9 +6570,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
@@ -5847,10 +6585,10 @@ Tcl_Tell(chan)
*/
int
-Tcl_SeekOld(chan, offset, mode)
- Tcl_Channel chan; /* The channel on which to seek. */
- int offset; /* Offset to seek to. */
- int mode; /* Relative to which location to seek? */
+Tcl_SeekOld(
+ Tcl_Channel chan, /* The channel on which to seek. */
+ int offset, /* Offset to seek to. */
+ int mode) /* Relative to which location to seek? */
{
Tcl_WideInt wOffset, wResult;
@@ -5860,8 +6598,8 @@ Tcl_SeekOld(chan, offset, mode)
}
int
-Tcl_TellOld(chan)
- Tcl_Channel chan; /* The channel to return pos for. */
+Tcl_TellOld(
+ Tcl_Channel chan) /* The channel to return pos for. */
{
Tcl_WideInt wResult;
@@ -5872,28 +6610,98 @@ Tcl_TellOld(chan)
/*
*---------------------------------------------------------------------------
*
+ * Tcl_TruncateChannel --
+ *
+ * Truncate a channel to the given length.
+ *
+ * Results:
+ * TCL_OK on success, TCL_ERROR if the operation failed (e.g. is not
+ * supported by the type of channel, or the underlying OS operation
+ * failed in some way).
+ *
+ * Side effects:
+ * Seeks the channel to the current location. Sets errno on OS error.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_TruncateChannel(
+ Tcl_Channel chan, /* Channel to truncate. */
+ Tcl_WideInt length) /* Length to truncate it to. */
+{
+ Channel *chanPtr = (Channel *) chan;
+ Tcl_DriverTruncateProc *truncateProc =
+ Tcl_ChannelTruncateProc(chanPtr->typePtr);
+ int result;
+
+ if (truncateProc == NULL) {
+ /*
+ * Feature not supported and it's not emulatable. Pretend it's
+ * returned an EINVAL, a very generic error!
+ */
+
+ Tcl_SetErrno(EINVAL);
+ return TCL_ERROR;
+ }
+
+ if (!(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.
+ */
+
+ Tcl_SetErrno(EINVAL);
+ return TCL_ERROR;
+ }
+
+ /*
+ * Seek first to force a total flush of all pending buffers and ditch any
+ * pre-read input data.
+ */
+
+ if (Tcl_Seek(chan, (Tcl_WideInt)0, SEEK_CUR) == Tcl_LongAsWide(-1)) {
+ return TCL_ERROR;
+ }
+
+ /*
+ * We're all flushed to disk now and we also don't have any unfortunate
+ * input baggage around either; can truncate with impunity.
+ */
+
+ result = truncateProc(chanPtr->instanceData, length);
+ if (result != 0) {
+ Tcl_SetErrno(result);
+ return TCL_ERROR;
+ }
+ return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
* CheckChannelErrors --
*
- * See if the channel is in an ready state and can perform the
- * desired operation.
+ * See if the channel is in an ready state and can perform the desired
+ * operation.
*
* Results:
- * The return value is 0 if the channel is OK, otherwise the
- * return value is -1 and errno is set to indicate the error.
+ * The return value is 0 if the channel is OK, otherwise the return value
+ * is -1 and errno is set to indicate the error.
*
* Side effects:
* May clear the EOF and/or BLOCKED bits if reading from channel.
*
*---------------------------------------------------------------------------
*/
-
+
static int
-CheckChannelErrors(statePtr, flags)
- ChannelState *statePtr; /* Channel to check. */
- int flags; /* Test if channel supports desired operation:
- * TCL_READABLE, TCL_WRITABLE. Also indicates
+CheckChannelErrors(
+ ChannelState *statePtr, /* Channel to check. */
+ int flags) /* Test if channel supports desired operation:
+ * TCL_READABLE, TCL_WRITABLE. Also indicates
* Raw read or write for special close
- * processing*/
+ * processing */
{
int direction = flags & (TCL_READABLE|TCL_WRITABLE);
@@ -5902,20 +6710,31 @@ CheckChannelErrors(statePtr, flags)
*/
if (statePtr->unreportedError != 0) {
- Tcl_SetErrno(statePtr->unreportedError);
- statePtr->unreportedError = 0;
- return -1;
+ Tcl_SetErrno(statePtr->unreportedError);
+ statePtr->unreportedError = 0;
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
+ * Move a defered error message back into the channel bypass.
+ */
+
+ if (statePtr->chanMsg != NULL) {
+ TclDecrRefCount(statePtr->chanMsg);
+ }
+ statePtr->chanMsg = statePtr->unreportedMsg;
+ statePtr->unreportedMsg = NULL;
+ return -1;
}
/*
- * 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) &&
((flags & CHANNEL_RAW_MODE) == 0)) {
- Tcl_SetErrno(EACCES);
- return -1;
+ Tcl_SetErrno(EACCES);
+ return -1;
}
/*
@@ -5923,8 +6742,8 @@ CheckChannelErrors(statePtr, flags)
*/
if ((statePtr->flags & direction) == 0) {
- Tcl_SetErrno(EACCES);
- return -1;
+ Tcl_SetErrno(EACCES);
+ return -1;
}
/*
@@ -5942,16 +6761,16 @@ 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) {
- statePtr->flags &= ~CHANNEL_EOF;
+ ResetFlag(statePtr, CHANNEL_EOF);
}
- statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+ ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
}
return 0;
@@ -5974,15 +6793,15 @@ CheckChannelErrors(statePtr, flags)
*/
int
-Tcl_Eof(chan)
- Tcl_Channel chan; /* Does this channel have EOF? */
+Tcl_Eof(
+ Tcl_Channel chan) /* Does this channel have EOF? */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return ((statePtr->flags & CHANNEL_STICKY_EOF) ||
- ((statePtr->flags & CHANNEL_EOF) &&
- (Tcl_InputBuffered(chan) == 0))) ? 1 : 0;
+ ((statePtr->flags & CHANNEL_EOF) &&
+ (Tcl_InputBuffered(chan) == 0))) ? 1 : 0;
}
/*
@@ -6002,11 +6821,11 @@ Tcl_Eof(chan)
*/
int
-Tcl_InputBlocked(chan)
- Tcl_Channel chan; /* Is this channel blocked? */
+Tcl_InputBlocked(
+ Tcl_Channel chan) /* Is this channel blocked? */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
}
@@ -6016,12 +6835,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.
@@ -6030,28 +6849,26 @@ Tcl_InputBlocked(chan)
*/
int
-Tcl_InputBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_InputBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
- for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
- bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; bufPtr != NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += BytesLeft(bufPtr);
}
/*
* Don't forget the bytes in the topmost pushback area.
*/
- for (bufPtr = statePtr->topChanPtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
- bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ for (bufPtr = statePtr->topChanPtr->inQueueHead; bufPtr != NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += BytesLeft(bufPtr);
}
return bytesBuffered;
@@ -6062,12 +6879,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.
@@ -6076,24 +6893,24 @@ Tcl_InputBuffered(chan)
*/
int
-Tcl_OutputBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_OutputBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
- for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
- bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += BytesLeft(bufPtr);
}
- if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
- statePtr->flags |= BUFFER_READY;
- bytesBuffered +=
- (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
+ if (statePtr->curOutPtr != NULL) {
+ register ChannelBuffer *curOutPtr = statePtr->curOutPtr;
+
+ if (IsBufferReady(curOutPtr)) {
+ bytesBuffered += BytesLeft(curOutPtr);
+ }
}
return bytesBuffered;
@@ -6108,8 +6925,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.
@@ -6118,18 +6935,17 @@ Tcl_OutputBuffered(chan)
*/
int
-Tcl_ChannelBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_ChannelBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
Channel *chanPtr = (Channel *) chan;
- /* real channel structure. */
+ /* Real channel structure. */
ChannelBuffer *bufPtr;
- int bytesBuffered;
+ int bytesBuffered = 0;
- for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
- bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ for (bufPtr = chanPtr->inQueueHead; bufPtr != NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += BytesLeft(bufPtr);
}
return bytesBuffered;
@@ -6140,8 +6956,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.
@@ -6153,13 +6969,12 @@ Tcl_ChannelBuffered(chan)
*/
void
-Tcl_SetChannelBufferSize(chan, sz)
- Tcl_Channel chan; /* The channel whose buffer size
- * to set. */
- int sz; /* The size to set. */
+Tcl_SetChannelBufferSize(
+ Tcl_Channel chan, /* The channel whose buffer size to set. */
+ int sz) /* The size to set. */
{
- ChannelState *statePtr; /* State of real channel structure. */
-
+ ChannelState *statePtr; /* State of real channel structure. */
+
/*
* Clip the buffer size to force it into the [1,1M] range
*/
@@ -6179,7 +6994,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));
}
}
@@ -6200,12 +7015,12 @@ Tcl_SetChannelBufferSize(chan, sz)
*/
int
-Tcl_GetChannelBufferSize(chan)
- Tcl_Channel chan; /* The channel for which to find the
- * buffer size. */
+Tcl_GetChannelBufferSize(
+ Tcl_Channel chan) /* The channel for which to find the buffer
+ * size. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return statePtr->bufSize;
}
@@ -6215,44 +7030,43 @@ 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
- * <...generic options...>+<...specific options...>
- * "blah" is the optionName argument and "<specific options>"
- * is a space separated list of specific option words.
- * The function takes good care of inserting minus signs before
- * each option, commas after, and an "or" before the last option.
+
+ * An error message is generated in interp's result object to indicate
+ * that a command was invoked with the a bad option. The message has the
+ * form:
+ * bad option "blah": should be one of
+ * <...generic options...>+<...specific options...>
+ * "blah" is the optionName argument and "<specific options>" is a space
+ * separated list of specific option words. The function takes good care
+ * of inserting minus signs before each option, commas after, and an "or"
+ * before the last option.
*
*----------------------------------------------------------------------
*/
int
-Tcl_BadChannelOption(interp, optionName, optionList)
- Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/
- CONST char *optionName; /* 'bad option' name */
- CONST char *optionList; /* Specific options list to append
- * to the standard generic options.
- * can be NULL for generic options
- * only.
- */
-{
- if (interp) {
- CONST char *genericopt =
- "blocking buffering buffersize encoding eofchar translation";
- CONST char **argv;
- int argc, i;
+Tcl_BadChannelOption(
+ Tcl_Interp *interp, /* Current interpreter (can be NULL).*/
+ const char *optionName, /* 'bad option' name */
+ const char *optionList) /* Specific options list to append to the
+ * standard generic options. Can be NULL for
+ * generic options only. */
+{
+ if (interp != NULL) {
+ const char *genericopt =
+ "blocking buffering buffersize encoding eofchar translation";
+ const char **argv;
+ int argc, i;
Tcl_DString ds;
Tcl_DStringInit(&ds);
@@ -6261,18 +7075,18 @@ 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) {
- panic("malformed option list in channel driver");
+ Tcl_Panic("malformed option list in channel driver");
}
Tcl_ResetResult(interp);
- Tcl_AppendResult(interp, "bad option \"", optionName,
- "\": should be one of ", (char *) NULL);
+ Tcl_AppendResult(interp, "bad option \"", optionName,
+ "\": should be one of ", NULL);
argc--;
for (i = 0; i < argc; i++) {
- Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
+ Tcl_AppendResult(interp, "-", argv[i], ", ", NULL);
}
- Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL);
+ Tcl_AppendResult(interp, "or -", argv[i], NULL);
Tcl_DStringFree(&ds);
ckfree((char *) argv);
}
@@ -6285,39 +7099,40 @@ 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.
+ * None.
*
*----------------------------------------------------------------------
*/
int
-Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
- Tcl_Interp *interp; /* For error reporting - can be NULL. */
- Tcl_Channel chan; /* Channel on which to get option. */
- CONST char *optionName; /* Option to get. */
- Tcl_DString *dsPtr; /* Where to store value(s). */
+Tcl_GetChannelOption(
+ Tcl_Interp *interp, /* For error reporting - can be NULL. */
+ Tcl_Channel chan, /* Channel on which to get option. */
+ const char *optionName, /* Option to get. */
+ Tcl_DString *dsPtr) /* Where to store value(s). */
{
size_t len; /* Length of optionName string. */
char optionVal[128]; /* Buffer for sprintf. */
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int flags;
/*
* Disallow options on dead channels -- channels that have been closed but
* not yet been deallocated. Such channels can be found if the exit
- * handler for channel cleanup has run but the channel is still
- * registered in an interpreter.
+ * handler for channel cleanup has run but the channel is still registered
+ * in an interpreter.
*/
if (CheckForDeadChannel(interp, statePtr)) {
@@ -6343,57 +7158,52 @@ 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) {
- len = 0;
+
+ if (optionName == NULL) {
+ len = 0;
} else {
- len = strlen(optionName);
- }
-
- if ((len == 0) || ((len > 2) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-blocking", len) == 0))) {
- if (len == 0) {
- Tcl_DStringAppendElement(dsPtr, "-blocking");
- }
- Tcl_DStringAppendElement(dsPtr,
+ len = strlen(optionName);
+ }
+
+ if (len == 0 || HaveOpt(2, "-blocking")) {
+ if (len == 0) {
+ Tcl_DStringAppendElement(dsPtr, "-blocking");
+ }
+ Tcl_DStringAppendElement(dsPtr,
(flags & CHANNEL_NONBLOCKING) ? "0" : "1");
- if (len > 0) {
- return TCL_OK;
- }
- }
- if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-buffering", len) == 0))) {
- if (len == 0) {
- Tcl_DStringAppendElement(dsPtr, "-buffering");
- }
- if (flags & CHANNEL_LINEBUFFERED) {
- Tcl_DStringAppendElement(dsPtr, "line");
- } else if (flags & CHANNEL_UNBUFFERED) {
- Tcl_DStringAppendElement(dsPtr, "none");
- } else {
- Tcl_DStringAppendElement(dsPtr, "full");
- }
- if (len > 0) {
- return TCL_OK;
- }
- }
- if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-buffersize", len) == 0))) {
- if (len == 0) {
- Tcl_DStringAppendElement(dsPtr, "-buffersize");
- }
- TclFormatInt(optionVal, statePtr->bufSize);
- Tcl_DStringAppendElement(dsPtr, optionVal);
- if (len > 0) {
- return TCL_OK;
- }
- }
- if ((len == 0) ||
- ((len > 2) && (optionName[1] == 'e') &&
- (strncmp(optionName, "-encoding", len) == 0))) {
+ if (len > 0) {
+ return TCL_OK;
+ }
+ }
+ if (len == 0 || HaveOpt(7, "-buffering")) {
+ if (len == 0) {
+ Tcl_DStringAppendElement(dsPtr, "-buffering");
+ }
+ if (flags & CHANNEL_LINEBUFFERED) {
+ Tcl_DStringAppendElement(dsPtr, "line");
+ } else if (flags & CHANNEL_UNBUFFERED) {
+ Tcl_DStringAppendElement(dsPtr, "none");
+ } else {
+ Tcl_DStringAppendElement(dsPtr, "full");
+ }
+ if (len > 0) {
+ return TCL_OK;
+ }
+ }
+ if (len == 0 || HaveOpt(7, "-buffersize")) {
+ if (len == 0) {
+ Tcl_DStringAppendElement(dsPtr, "-buffersize");
+ }
+ TclFormatInt(optionVal, statePtr->bufSize);
+ Tcl_DStringAppendElement(dsPtr, optionVal);
+ if (len > 0) {
+ return TCL_OK;
+ }
+ }
+ if (len == 0 || HaveOpt(2, "-encoding")) {
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-encoding");
}
@@ -6407,108 +7217,111 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
return TCL_OK;
}
}
- if ((len == 0) ||
- ((len > 2) && (optionName[1] == 'e') &&
- (strncmp(optionName, "-eofchar", len) == 0))) {
- if (len == 0) {
- Tcl_DStringAppendElement(dsPtr, "-eofchar");
- }
- if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
- (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
- Tcl_DStringStartSublist(dsPtr);
- }
- if (flags & TCL_READABLE) {
- if (statePtr->inEofChar == 0) {
- Tcl_DStringAppendElement(dsPtr, "");
- } else {
- char buf[4];
-
- sprintf(buf, "%c", statePtr->inEofChar);
- Tcl_DStringAppendElement(dsPtr, buf);
- }
- }
- if (flags & TCL_WRITABLE) {
- if (statePtr->outEofChar == 0) {
- Tcl_DStringAppendElement(dsPtr, "");
- } else {
- char buf[4];
-
- sprintf(buf, "%c", statePtr->outEofChar);
- Tcl_DStringAppendElement(dsPtr, buf);
- }
- }
- if ( !(flags & (TCL_READABLE|TCL_WRITABLE))) {
- /* Not readable or writable (server socket) */
- Tcl_DStringAppendElement(dsPtr, "");
- }
- if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
- (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
- Tcl_DStringEndSublist(dsPtr);
- }
- if (len > 0) {
- return TCL_OK;
- }
- }
- if ((len == 0) ||
- ((len > 1) && (optionName[1] == 't') &&
- (strncmp(optionName, "-translation", len) == 0))) {
- if (len == 0) {
- Tcl_DStringAppendElement(dsPtr, "-translation");
- }
- if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
- (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
- Tcl_DStringStartSublist(dsPtr);
- }
- if (flags & TCL_READABLE) {
- if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
- Tcl_DStringAppendElement(dsPtr, "auto");
- } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
- Tcl_DStringAppendElement(dsPtr, "cr");
- } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
- Tcl_DStringAppendElement(dsPtr, "crlf");
- } else {
- Tcl_DStringAppendElement(dsPtr, "lf");
- }
- }
- if (flags & TCL_WRITABLE) {
- if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
- Tcl_DStringAppendElement(dsPtr, "auto");
- } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
- Tcl_DStringAppendElement(dsPtr, "cr");
- } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
- Tcl_DStringAppendElement(dsPtr, "crlf");
- } else {
- Tcl_DStringAppendElement(dsPtr, "lf");
- }
- }
- if ( !(flags & (TCL_READABLE|TCL_WRITABLE))) {
- /* Not readable or writable (server socket) */
- Tcl_DStringAppendElement(dsPtr, "auto");
- }
- if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
- (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
- Tcl_DStringEndSublist(dsPtr);
- }
- if (len > 0) {
- return TCL_OK;
- }
- }
- if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) {
+ if (len == 0 || HaveOpt(2, "-eofchar")) {
+ if (len == 0) {
+ Tcl_DStringAppendElement(dsPtr, "-eofchar");
+ }
+ if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+ (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+ Tcl_DStringStartSublist(dsPtr);
+ }
+ if (flags & TCL_READABLE) {
+ if (statePtr->inEofChar == 0) {
+ Tcl_DStringAppendElement(dsPtr, "");
+ } else {
+ char buf[4];
+
+ sprintf(buf, "%c", statePtr->inEofChar);
+ Tcl_DStringAppendElement(dsPtr, buf);
+ }
+ }
+ if (flags & TCL_WRITABLE) {
+ if (statePtr->outEofChar == 0) {
+ Tcl_DStringAppendElement(dsPtr, "");
+ } else {
+ char buf[4];
+
+ sprintf(buf, "%c", statePtr->outEofChar);
+ Tcl_DStringAppendElement(dsPtr, buf);
+ }
+ }
+ if (!(flags & (TCL_READABLE|TCL_WRITABLE))) {
+ /*
+ * Not readable or writable (e.g. server socket)
+ */
+
+ Tcl_DStringAppendElement(dsPtr, "");
+ }
+ if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+ (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+ Tcl_DStringEndSublist(dsPtr);
+ }
+ if (len > 0) {
+ return TCL_OK;
+ }
+ }
+ if (len == 0 || HaveOpt(1, "-translation")) {
+ if (len == 0) {
+ Tcl_DStringAppendElement(dsPtr, "-translation");
+ }
+ if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+ (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+ Tcl_DStringStartSublist(dsPtr);
+ }
+ if (flags & TCL_READABLE) {
+ if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
+ Tcl_DStringAppendElement(dsPtr, "auto");
+ } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
+ Tcl_DStringAppendElement(dsPtr, "cr");
+ } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
+ Tcl_DStringAppendElement(dsPtr, "crlf");
+ } else {
+ Tcl_DStringAppendElement(dsPtr, "lf");
+ }
+ }
+ if (flags & TCL_WRITABLE) {
+ if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
+ Tcl_DStringAppendElement(dsPtr, "auto");
+ } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
+ Tcl_DStringAppendElement(dsPtr, "cr");
+ } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
+ Tcl_DStringAppendElement(dsPtr, "crlf");
+ } else {
+ Tcl_DStringAppendElement(dsPtr, "lf");
+ }
+ }
+ if (!(flags & (TCL_READABLE|TCL_WRITABLE))) {
+ /*
+ * Not readable or writable (e.g. server socket)
+ */
+
+ Tcl_DStringAppendElement(dsPtr, "auto");
+ }
+ if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+ (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+ Tcl_DStringEndSublist(dsPtr);
+ }
+ if (len > 0) {
+ return TCL_OK;
+ }
+ }
+
+ if (chanPtr->typePtr->getOptionProc != 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,
+ return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
interp, optionName, dsPtr);
} else {
/*
- * no driver specific options case.
+ * No driver specific options case.
*/
- if (len == 0) {
- return TCL_OK;
- }
+ if (len == 0) {
+ return TCL_OK;
+ }
return Tcl_BadChannelOption(interp, optionName, NULL);
}
}
@@ -6521,8 +7334,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.
@@ -6531,17 +7344,19 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
*/
int
-Tcl_SetChannelOption(interp, chan, optionName, newValue)
- Tcl_Interp *interp; /* For error reporting - can be NULL. */
- Tcl_Channel chan; /* Channel on which to set mode. */
- CONST char *optionName; /* Which option to set? */
- CONST char *newValue; /* New value for option. */
-{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+Tcl_SetChannelOption(
+ Tcl_Interp *interp, /* For error reporting - can be NULL. */
+ Tcl_Channel chan, /* Channel on which to set mode. */
+ const char *optionName, /* Which option to set? */
+ const char *newValue) /* New value for option. */
+{
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
size_t len; /* Length of optionName string. */
int argc;
- CONST char **argv;
+ const char **argv;
/*
* If the channel is in the middle of a background copy, fail.
@@ -6549,18 +7364,17 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
if (statePtr->csPtrR || statePtr->csPtrW) {
if (interp) {
- Tcl_AppendResult(interp,
- "unable to set channel options: background copy in progress",
- (char *) NULL);
+ Tcl_AppendResult(interp, "unable to set channel options: "
+ "background copy in progress", NULL);
}
- return TCL_ERROR;
+ return TCL_ERROR;
}
/*
* Disallow options on dead channels -- channels that have been closed but
* not yet been deallocated. Such channels can be found if the exit
- * handler for channel cleanup has run but the channel is still
- * registered in an interpreter.
+ * handler for channel cleanup has run but the channel is still registered
+ * in an interpreter.
*/
if (CheckForDeadChannel(NULL, statePtr)) {
@@ -6575,50 +7389,47 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
len = strlen(optionName);
- if ((len > 2) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-blocking", len) == 0)) {
+ if (HaveOpt(2, "-blocking")) {
int newMode;
- if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) {
- return TCL_ERROR;
- }
- if (newMode) {
- newMode = TCL_MODE_BLOCKING;
- } else {
- newMode = TCL_MODE_NONBLOCKING;
- }
+
+ if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) {
+ return TCL_ERROR;
+ }
+ if (newMode) {
+ newMode = TCL_MODE_BLOCKING;
+ } else {
+ newMode = TCL_MODE_NONBLOCKING;
+ }
return SetBlockMode(interp, chanPtr, newMode);
- } else if ((len > 7) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-buffering", len) == 0)) {
- len = strlen(newValue);
- if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
- statePtr->flags &=
- (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
- } else if ((newValue[0] == 'l') &&
- (strncmp(newValue, "line", len) == 0)) {
- statePtr->flags &= (~(CHANNEL_UNBUFFERED));
- statePtr->flags |= CHANNEL_LINEBUFFERED;
- } else if ((newValue[0] == 'n') &&
- (strncmp(newValue, "none", len) == 0)) {
- statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
- statePtr->flags |= CHANNEL_UNBUFFERED;
- } else {
- if (interp) {
- Tcl_AppendResult(interp, "bad value for -buffering: ",
- "must be one of full, line, or none",
- (char *) NULL);
- return TCL_ERROR;
- }
- }
+ } else if (HaveOpt(7, "-buffering")) {
+ len = strlen(newValue);
+ if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
+ statePtr->flags &=
+ ~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED);
+ } else if ((newValue[0] == 'l') &&
+ (strncmp(newValue, "line", len) == 0)) {
+ ResetFlag(statePtr, CHANNEL_UNBUFFERED);
+ SetFlag(statePtr, CHANNEL_LINEBUFFERED);
+ } else if ((newValue[0] == 'n') &&
+ (strncmp(newValue, "none", len) == 0)) {
+ ResetFlag(statePtr, CHANNEL_LINEBUFFERED);
+ SetFlag(statePtr, CHANNEL_UNBUFFERED);
+ } else {
+ if (interp) {
+ Tcl_AppendResult(interp, "bad value for -buffering: "
+ "must be one of full, line, or none", NULL);
+ return TCL_ERROR;
+ }
+ }
return TCL_OK;
- } else if ((len > 7) && (optionName[1] == 'b') &&
- (strncmp(optionName, "-buffersize", len) == 0)) {
+ } else if (HaveOpt(7, "-buffersize")) {
int newBufferSize;
+
if (Tcl_GetInt(interp, newValue, &newBufferSize) == TCL_ERROR) {
return TCL_ERROR;
}
Tcl_SetChannelBufferSize(chan, newBufferSize);
- } else if ((len > 2) && (optionName[1] == 'e') &&
- (strncmp(optionName, "-encoding", len) == 0)) {
+ } else if (HaveOpt(2, "-encoding")) {
Tcl_Encoding encoding;
if ((newValue[0] == '\0') || (strcmp(newValue, "binary") == 0)) {
@@ -6629,10 +7440,12 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
return TCL_ERROR;
}
}
+
/*
* When the channel has an escape sequence driven encoding such as
* iso2022, the terminated escape sequence must write to the buffer.
*/
+
if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL)
&& (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) {
statePtr->outputEncodingFlags |= TCL_ENCODING_END;
@@ -6644,74 +7457,77 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
statePtr->inputEncodingFlags = TCL_ENCODING_START;
statePtr->outputEncodingState = NULL;
statePtr->outputEncodingFlags = TCL_ENCODING_START;
- statePtr->flags &= ~CHANNEL_NEED_MORE_DATA;
+ ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
UpdateInterest(chanPtr);
- } else if ((len > 2) && (optionName[1] == 'e') &&
- (strncmp(optionName, "-eofchar", len) == 0)) {
- if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
- return TCL_ERROR;
- }
- if (argc == 0) {
- statePtr->inEofChar = 0;
- statePtr->outEofChar = 0;
- } else if (argc == 1) {
- if (statePtr->flags & TCL_WRITABLE) {
- statePtr->outEofChar = (int) argv[0][0];
- }
- if (statePtr->flags & TCL_READABLE) {
- statePtr->inEofChar = (int) argv[0][0];
- }
- } else if (argc != 2) {
- if (interp) {
- Tcl_AppendResult(interp,
- "bad value for -eofchar: should be a list of zero,",
- " one, or two elements", (char *) NULL);
- }
- ckfree((char *) argv);
- return TCL_ERROR;
- } else {
- if (statePtr->flags & TCL_READABLE) {
- statePtr->inEofChar = (int) argv[0][0];
- }
- if (statePtr->flags & TCL_WRITABLE) {
- statePtr->outEofChar = (int) argv[1][0];
- }
- }
- if (argv != NULL) {
- ckfree((char *) argv);
- }
+ } else if (HaveOpt(2, "-eofchar")) {
+ if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
+ return TCL_ERROR;
+ }
+ if (argc == 0) {
+ statePtr->inEofChar = 0;
+ statePtr->outEofChar = 0;
+ } else if (argc == 1 || argc == 2) {
+ int outIndex = (argc - 1);
+ int inValue = (int) argv[0][0];
+ int outValue = (int) argv[outIndex][0];
+ if (inValue & 0x80 || outValue & 0x80) {
+ if (interp) {
+ Tcl_AppendResult(interp, "bad value for -eofchar: ",
+ "must be non-NUL ASCII character", NULL);
+ }
+ ckfree((char *) argv);
+ return TCL_ERROR;
+ }
+ if (statePtr->flags & TCL_READABLE) {
+ statePtr->inEofChar = inValue;
+ }
+ if (statePtr->flags & TCL_WRITABLE) {
+ statePtr->outEofChar = outValue;
+ }
+ } else {
+ if (interp) {
+ Tcl_AppendResult(interp,
+ "bad value for -eofchar: should be a list of zero,"
+ " one, or two elements", NULL);
+ }
+ ckfree((char *) argv);
+ return TCL_ERROR;
+ }
+ if (argv != NULL) {
+ ckfree((char *) argv);
+ }
/*
- * [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.
+ * [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 &= (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED));
+ statePtr->flags &=
+ ~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED);
return TCL_OK;
- } else if ((len > 1) && (optionName[1] == 't') &&
- (strncmp(optionName, "-translation", len) == 0)) {
- CONST char *readMode, *writeMode;
+ } else if (HaveOpt(1, "-translation")) {
+ const char *readMode, *writeMode;
- if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
- return TCL_ERROR;
- }
+ if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
+ return TCL_ERROR;
+ }
- if (argc == 1) {
+ if (argc == 1) {
readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
} else if (argc == 2) {
readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
} else {
- if (interp) {
- Tcl_AppendResult(interp,
- "bad value for -translation: must be a one or two",
- " element list", (char *) NULL);
- }
- ckfree((char *) argv);
- return TCL_ERROR;
+ if (interp) {
+ Tcl_AppendResult(interp,
+ "bad value for -translation: must be a one or two"
+ " element list", NULL);
+ }
+ ckfree((char *) argv);
+ return TCL_ERROR;
}
if (readMode) {
@@ -6723,7 +7539,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;
@@ -6736,24 +7552,23 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
} else {
if (interp) {
Tcl_AppendResult(interp,
- "bad value for -translation: ",
- "must be one of auto, binary, cr, lf, crlf,",
- " or platform", (char *) NULL);
+ "bad value for -translation: "
+ "must be one of auto, binary, cr, lf, crlf,"
+ " or platform", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
}
/*
- * Reset the EOL flags since we need to look at any buffered
- * data to see if the new translation mode allows us to
- * complete the line.
+ * Reset the EOL flags since we need to look at any buffered data
+ * to see if the new translation mode allows us to complete the
+ * line.
*/
if (translation != statePtr->inputTranslation) {
statePtr->inputTranslation = translation;
- statePtr->flags &= ~(INPUT_SAW_CR);
- statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
+ ResetFlag(statePtr, INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA);
UpdateInterest(chanPtr);
}
}
@@ -6762,10 +7577,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) {
@@ -6776,7 +7590,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;
@@ -6789,21 +7603,21 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
} else {
if (interp) {
Tcl_AppendResult(interp,
- "bad value for -translation: ",
- "must be one of auto, binary, cr, lf, crlf,",
- " or platform", (char *) NULL);
+ "bad value for -translation: "
+ "must be one of auto, binary, cr, lf, crlf,"
+ " or platform", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
}
}
- ckfree((char *) argv);
- return TCL_OK;
+ ckfree((char *) argv);
+ return TCL_OK;
} else if (chanPtr->typePtr->setOptionProc != NULL) {
- return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData,
- interp, optionName, newValue);
+ return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData,
+ interp, optionName, newValue);
} else {
- return Tcl_BadChannelOption(interp, optionName, (char *) NULL);
+ return Tcl_BadChannelOption(interp, optionName, NULL);
}
/*
@@ -6814,14 +7628,12 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
statePtr->saveInBufPtr = NULL;
}
- if (statePtr->inQueueHead != NULL) {
- if ((statePtr->inQueueHead->nextPtr == NULL)
- && (statePtr->inQueueHead->nextAdded ==
- statePtr->inQueueHead->nextRemoved)) {
- RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
- statePtr->inQueueHead = NULL;
- statePtr->inQueueTail = NULL;
- }
+ if ((statePtr->inQueueHead != NULL)
+ && (statePtr->inQueueHead->nextPtr == NULL)
+ && IsBufferEmpty(statePtr->inQueueHead)) {
+ RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
}
/*
@@ -6829,12 +7641,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
*/
if (statePtr->outputStage != NULL) {
- ckfree((char *) statePtr->outputStage);
+ ckfree(statePtr->outputStage);
statePtr->outputStage = NULL;
}
if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
- statePtr->outputStage = (char *)
- ckalloc((unsigned) (statePtr->bufSize + 2));
+ statePtr->outputStage = ckalloc((unsigned) (statePtr->bufSize + 2));
}
return TCL_OK;
}
@@ -6844,11 +7655,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.
@@ -6860,38 +7670,37 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
*/
static void
-CleanupChannelHandlers(interp, chanPtr)
- Tcl_Interp *interp;
- Channel *chanPtr;
+CleanupChannelHandlers(
+ Tcl_Interp *interp,
+ Channel *chanPtr)
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
/*
- * Remove fileevent records on this channel that refer to the
- * given interpreter.
+ * Remove fileevent records on this channel that refer to the given
+ * interpreter.
*/
-
- for (sPtr = statePtr->scriptRecordPtr,
- prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
- nextPtr = sPtr->nextPtr;
- if (sPtr->interp == interp) {
- if (prevPtr == (EventScriptRecord *) NULL) {
- statePtr->scriptRecordPtr = nextPtr;
- } else {
- prevPtr->nextPtr = nextPtr;
- }
- Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
- TclChannelEventScriptInvoker, (ClientData) sPtr);
+ for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+ sPtr != NULL; sPtr = nextPtr) {
+ nextPtr = sPtr->nextPtr;
+ if (sPtr->interp == interp) {
+ if (prevPtr == NULL) {
+ statePtr->scriptRecordPtr = nextPtr;
+ } else {
+ prevPtr->nextPtr = nextPtr;
+ }
+
+ Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+ TclChannelEventScriptInvoker, sPtr);
- Tcl_DecrRefCount(sPtr->scriptPtr);
- ckfree((char *) sPtr);
- } else {
- prevPtr = sPtr;
- }
+ TclDecrRefCount(sPtr->scriptPtr);
+ ckfree((char *) sPtr);
+ } else {
+ prevPtr = sPtr;
+ }
}
}
@@ -6900,10 +7709,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.
@@ -6915,62 +7723,62 @@ CleanupChannelHandlers(interp, chanPtr)
*/
void
-Tcl_NotifyChannel(channel, mask)
- Tcl_Channel channel; /* Channel that detected an event. */
- int mask; /* OR'ed combination of TCL_READABLE,
+Tcl_NotifyChannel(
+ Tcl_Channel channel, /* Channel that detected an event. */
+ int mask) /* OR'ed combination of TCL_READABLE,
* TCL_WRITABLE, or TCL_EXCEPTION: indicates
* which events were detected. */
{
Channel *chanPtr = (Channel *) channel;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelHandler *chPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
NextChannelHandler nh;
- Channel* upChanPtr;
- Tcl_ChannelType* upTypePtr;
+ Channel *upChanPtr;
+ const 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) &&
- (statePtr->flags & CHANNEL_NONBLOCKING) &&
- (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
- !(statePtr->flags & CHANNEL_TIMER_FEV)) {
-
- statePtr->flags |= CHANNEL_HAS_MORE_DATA;
+ (statePtr->flags & CHANNEL_NONBLOCKING) &&
+ (Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
+ !(statePtr->flags & CHANNEL_TIMER_FEV)) {
+ SetFlag(statePtr, CHANNEL_HAS_MORE_DATA);
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
/*
- * In contrast to the other API functions this procedure walks towards
- * the top of a stack and not down from it.
+ * In contrast to the other API functions this procedure walks towards the
+ * top of a stack and not down from it.
*
* The channel calling this procedure is the one who generated the event,
- * and thus does not take part in handling it. IOW, its HandlerProc is
- * not called, instead we begin with the channel above it.
+ * and thus does not take part in handling it. IOW, its HandlerProc is not
+ * called, instead we begin with the channel above it.
*
- * This behaviour also allows the transformation channels to
- * generate their own events and pass them upward.
+ * This behaviour also allows the transformation channels to generate
+ * their own events and pass them upward.
*/
- while (mask && (chanPtr->upChanPtr != ((Channel*) NULL))) {
- Tcl_DriverHandlerProc* upHandlerProc;
+ while (mask && (chanPtr->upChanPtr != (NULL))) {
+ Tcl_DriverHandlerProc *upHandlerProc;
- upChanPtr = chanPtr->upChanPtr;
+ upChanPtr = chanPtr->upChanPtr;
upTypePtr = upChanPtr->typePtr;
upHandlerProc = Tcl_ChannelHandlerProc(upTypePtr);
if (upHandlerProc != NULL) {
mask = (*upHandlerProc) (upChanPtr->instanceData, mask);
}
- /* 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;
@@ -6979,29 +7787,28 @@ 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) {
- return;
+ return;
}
/*
- * We are now above the topmost channel in a stack and have events
- * left. Now call the channel handlers as usual.
+ * We are now above the topmost channel in a stack and have events left.
+ * Now call the channel handlers as usual.
*
* Preserve the channel struct in case the script closes it.
*/
-
- Tcl_Preserve((ClientData) channel);
- Tcl_Preserve((ClientData) statePtr);
+
+ Tcl_Preserve(channel);
+ Tcl_Preserve(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)) {
@@ -7013,12 +7820,12 @@ Tcl_NotifyChannel(channel, mask)
* Add this invocation to the list of recursive invocations of
* ChannelHandlerEventProc.
*/
-
- nh.nextHandlerPtr = (ChannelHandler *) NULL;
+
+ nh.nextHandlerPtr = NULL;
nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
tsdPtr->nestedHandlerPtr = &nh;
- for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; ) {
/*
* If this channel handler is interested in any of the events that
* have occurred on the channel, invoke its procedure.
@@ -7034,17 +7841,17 @@ 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) {
- UpdateInterest(chanPtr);
+ UpdateInterest(chanPtr);
}
- Tcl_Release((ClientData) statePtr);
- Tcl_Release((ClientData) channel);
+ Tcl_Release(statePtr);
+ Tcl_Release(channel);
tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr;
}
@@ -7054,8 +7861,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.
@@ -7067,15 +7874,16 @@ Tcl_NotifyChannel(channel, mask)
*/
static void
-UpdateInterest(chanPtr)
- Channel *chanPtr; /* Channel to update. */
+UpdateInterest(
+ Channel *chanPtr) /* Channel to update. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int mask = statePtr->interestMask;
/*
- * If there are flushed buffers waiting to be written, then
- * we need to watch for the channel to become writable.
+ * If there are flushed buffers waiting to be written, then we need to
+ * watch for the channel to become writable.
*/
if (statePtr->flags & BG_FLUSH_SCHEDULED) {
@@ -7085,62 +7893,59 @@ UpdateInterest(chanPtr)
/*
* If there is data in the input queue, and we aren't waiting for more
* data, then we need to schedule a timer so we don't block in the
- * notifier. Also, cancel the read interest so we don't get duplicate
+ * notifier. Also, cancel the read interest so we don't get duplicate
* events.
*/
if (mask & TCL_READABLE) {
if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
- && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
- && (statePtr->inQueueHead->nextRemoved <
- statePtr->inQueueHead->nextAdded)) {
+ && (statePtr->inQueueHead != NULL)
+ && IsBufferReady(statePtr->inQueueHead)) {
mask &= ~TCL_READABLE;
/*
* Andreas Kupries, April 11, 2003
*
- * Some operating systems (Solaris 2.6 and higher (but not
- * Solaris 2.5, go figure)) generate READABLE and
- * EXCEPTION events when select()'ing [*] on a plain file,
- * even if EOF was not yet reached. This is a problem in
- * the following situation:
+ * Some operating systems (Solaris 2.6 and higher (but not Solaris
+ * 2.5, go figure)) generate READABLE and EXCEPTION events when
+ * select()'ing [*] on a plain file, even if EOF was not yet
+ * reached. This is a problem in the following situation:
*
- * - An extension asks to get both READABLE and EXCEPTION
- * events.
- * - It reads data into a buffer smaller than the buffer
- * used by Tcl itself.
- * - It does not process all events in the event queue, but
- * only 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;
if (!statePtr->timer) {
statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
- (ClientData) chanPtr);
+ chanPtr);
}
}
}
@@ -7152,8 +7957,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.
@@ -7165,47 +7970,47 @@ UpdateInterest(chanPtr)
*/
static void
-ChannelTimerProc(clientData)
- ClientData clientData;
+ChannelTimerProc(
+ ClientData clientData)
{
- Channel *chanPtr = (Channel *) clientData;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = clientData;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
&& (statePtr->interestMask & TCL_READABLE)
- && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
- && (statePtr->inQueueHead->nextRemoved <
- statePtr->inQueueHead->nextAdded)) {
+ && (statePtr->inQueueHead != NULL)
+ && IsBufferReady(statePtr->inQueueHead)) {
/*
- * 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);
+ statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,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) &&
(Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL)) {
- statePtr->flags |= CHANNEL_TIMER_FEV;
+ SetFlag(statePtr, CHANNEL_TIMER_FEV);
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
- Tcl_Preserve((ClientData) statePtr);
+ Tcl_Preserve(statePtr);
Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE);
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
- statePtr->flags &= ~CHANNEL_TIMER_FEV;
+ ResetFlag(statePtr, CHANNEL_TIMER_FEV);
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
- Tcl_Release((ClientData) statePtr);
+ Tcl_Release(statePtr);
} else {
statePtr->timer = NULL;
UpdateInterest(chanPtr);
@@ -7217,80 +8022,75 @@ 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.
*
*----------------------------------------------------------------------
*/
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. */
- ClientData clientData; /* Arbitrary data to pass to proc. */
+Tcl_CreateChannelHandler(
+ Tcl_Channel chan, /* The channel to create the handler for. */
+ int mask, /* OR'ed combination of TCL_READABLE,
+ * TCL_WRITABLE, and TCL_EXCEPTION: indicates
+ * conditions under which proc should be
+ * called. Use 0 to disable a registered
+ * handler. */
+ Tcl_ChannelProc *proc, /* Procedure to call for each selected
+ * event. */
+ ClientData clientData) /* Arbitrary data to pass to proc. */
{
ChannelHandler *chPtr;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
- * Check whether this channel handler is not already registered. If
- * it is not, create a new record, else reuse existing record (smash
- * current values).
+ * Check whether this channel handler is not already registered. If it is
+ * not, create a new record, else reuse existing record (smash current
+ * values).
*/
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
- (chPtr->clientData == clientData)) {
- break;
- }
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
+ if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
+ (chPtr->clientData == clientData)) {
+ break;
+ }
}
- if (chPtr == (ChannelHandler *) NULL) {
- chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
- chPtr->mask = 0;
- chPtr->proc = proc;
- chPtr->clientData = clientData;
- chPtr->chanPtr = chanPtr;
- chPtr->nextPtr = statePtr->chPtr;
- statePtr->chPtr = chPtr;
+ if (chPtr == NULL) {
+ chPtr = (ChannelHandler *) ckalloc(sizeof(ChannelHandler));
+ chPtr->mask = 0;
+ chPtr->proc = proc;
+ chPtr->clientData = clientData;
+ chPtr->chanPtr = chanPtr;
+ chPtr->nextPtr = statePtr->chPtr;
+ statePtr->chPtr = chPtr;
}
/*
- * The remainder of the initialization below is done regardless of
- * whether or not this is a new record or a modification of an old
- * one.
+ * The remainder of the initialization below is done regardless of whether
+ * or not this is a new record or a modification of an old one.
*/
chPtr->mask = mask;
/*
- * Recompute the interest mask for the channel - this call may actually
- * be disabling an existing handler.
+ * Recompute the interest mask for the channel - this call may actually be
+ * disabling an existing handler.
*/
-
+
statePtr->interestMask = 0;
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
statePtr->interestMask |= chPtr->mask;
}
@@ -7302,55 +8102,53 @@ 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.
*
*----------------------------------------------------------------------
*/
void
-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. */
-
+Tcl_DeleteChannelHandler(
+ Tcl_Channel chan, /* The channel for which to remove the
+ * callback. */
+ Tcl_ChannelProc *proc, /* The procedure in the callback to delete. */
+ ClientData clientData) /* The client data in the callback to
+ * delete. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelHandler *chPtr, *prevChPtr;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
NextChannelHandler *nhPtr;
/*
* Find the entry and the previous one in the list.
*/
- for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
- && (chPtr->proc == proc)) {
- break;
- }
- prevChPtr = chPtr;
+ for (prevChPtr = NULL, chPtr = statePtr->chPtr; chPtr != NULL;
+ chPtr = chPtr->nextPtr) {
+ if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
+ && (chPtr->proc == proc)) {
+ break;
+ }
+ prevChPtr = chPtr;
}
/*
* If not found, return without doing anything.
*/
- if (chPtr == (ChannelHandler *) NULL) {
- return;
+ if (chPtr == NULL) {
+ return;
}
/*
@@ -7358,36 +8156,32 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* process the next one instead - we are going to delete *this* one.
*/
- for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
- nhPtr = nhPtr->nestedHandlerPtr) {
- if (nhPtr->nextHandlerPtr == chPtr) {
- nhPtr->nextHandlerPtr = chPtr->nextPtr;
- }
+ for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
+ nhPtr = nhPtr->nestedHandlerPtr) {
+ if (nhPtr->nextHandlerPtr == chPtr) {
+ nhPtr->nextHandlerPtr = chPtr->nextPtr;
+ }
}
/*
* Splice it out of the list of channel handlers.
*/
-
- if (prevChPtr == (ChannelHandler *) NULL) {
- statePtr->chPtr = chPtr->nextPtr;
+
+ if (prevChPtr == NULL) {
+ statePtr->chPtr = chPtr->nextPtr;
} else {
- prevChPtr->nextPtr = chPtr->nextPtr;
+ prevChPtr->nextPtr = chPtr->nextPtr;
}
ckfree((char *) chPtr);
/*
* Recompute the interest list for the channel, so that infinite loops
- * will not result if Tcl_DeleteChannelHandler is called inside an
- * event.
+ * will not result if Tcl_DeleteChannelHandler is called inside an event.
*/
statePtr->interestMask = 0;
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- statePtr->interestMask |= chPtr->mask;
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
+ statePtr->interestMask |= chPtr->mask;
}
UpdateInterest(statePtr->topChanPtr);
@@ -7398,8 +8192,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.
@@ -7411,36 +8205,35 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
*/
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. */
-{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+DeleteScriptRecord(
+ Tcl_Interp *interp, /* Interpreter in which script was to be
+ * executed. */
+ Channel *chanPtr, /* The channel for which to delete the script
+ * record (if any). */
+ int mask) /* Events in mask must exactly match mask of
+ * script to delete. */
+{
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *esPtr, *prevEsPtr;
- for (esPtr = statePtr->scriptRecordPtr,
- prevEsPtr = (EventScriptRecord *) NULL;
- esPtr != (EventScriptRecord *) NULL;
- prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
- if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
- if (esPtr == statePtr->scriptRecordPtr) {
- statePtr->scriptRecordPtr = esPtr->nextPtr;
- } else {
- prevEsPtr->nextPtr = esPtr->nextPtr;
- }
+ for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL;
+ prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
+ if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+ if (esPtr == statePtr->scriptRecordPtr) {
+ statePtr->scriptRecordPtr = esPtr->nextPtr;
+ } else {
+ prevEsPtr->nextPtr = esPtr->nextPtr;
+ }
+
+ Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+ TclChannelEventScriptInvoker, esPtr);
- Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
- TclChannelEventScriptInvoker, (ClientData) esPtr);
-
- Tcl_DecrRefCount(esPtr->scriptPtr);
- ckfree((char *) esPtr);
+ TclDecrRefCount(esPtr->scriptPtr);
+ ckfree((char *) esPtr);
- break;
- }
+ break;
+ }
}
}
@@ -7462,40 +8255,54 @@ 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_Obj *scriptPtr; /* Pointer to script object. */
-{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+CreateScriptRecord(
+ Tcl_Interp *interp, /* Interpreter in which to execute the stored
+ * script. */
+ Channel *chanPtr, /* Channel for which script is to be stored */
+ int mask, /* Set of events for which script will be
+ * invoked. */
+ Tcl_Obj *scriptPtr) /* Pointer to script object. */
+{
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *esPtr;
+ int makeCH;
- for (esPtr = statePtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
- esPtr = esPtr->nextPtr) {
- if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
- Tcl_DecrRefCount(esPtr->scriptPtr);
- esPtr->scriptPtr = (Tcl_Obj *) NULL;
- break;
- }
- }
- if (esPtr == (EventScriptRecord *) NULL) {
- esPtr = (EventScriptRecord *) ckalloc((unsigned)
- sizeof(EventScriptRecord));
- Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
- TclChannelEventScriptInvoker, (ClientData) esPtr);
- esPtr->nextPtr = statePtr->scriptRecordPtr;
- statePtr->scriptRecordPtr = esPtr;
+ for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
+ if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+ TclDecrRefCount(esPtr->scriptPtr);
+ esPtr->scriptPtr = NULL;
+ break;
+ }
}
+
+ makeCH = (esPtr == NULL);
+
+ if (makeCH) {
+ esPtr = (EventScriptRecord *) ckalloc(sizeof(EventScriptRecord));
+ }
+
+ /*
+ * Initialize the structure before calling Tcl_CreateChannelHandler,
+ * because a reflected channel caling 'chan postevent' aka
+ * 'Tcl_NotifyChannel' in its 'watch'Proc will invoke
+ * 'TclChannelEventScriptInvoker' immediately, and we do not wish it to
+ * see uninitialized memory and crash. See [Bug 2918110].
+ */
+
esPtr->chanPtr = chanPtr;
esPtr->interp = interp;
esPtr->mask = mask;
Tcl_IncrRefCount(scriptPtr);
esPtr->scriptPtr = scriptPtr;
+
+ if (makeCH) {
+ esPtr->nextPtr = statePtr->scriptRecordPtr;
+ statePtr->scriptRecordPtr = esPtr;
+
+ Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
+ TclChannelEventScriptInvoker, esPtr);
+ }
}
/*
@@ -7503,9 +8310,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,46 +8324,46 @@ CreateScriptRecord(interp, chanPtr, mask, scriptPtr)
*/
void
-TclChannelEventScriptInvoker(clientData, mask)
- ClientData clientData; /* The script+interp record. */
- int mask; /* Not used. */
+TclChannelEventScriptInvoker(
+ ClientData clientData, /* The script+interp record. */
+ int mask) /* Not used. */
{
Tcl_Interp *interp; /* Interpreter in which to eval the script. */
Channel *chanPtr; /* The channel for which this handler is
- * registered. */
+ * registered. */
EventScriptRecord *esPtr; /* The event script + interpreter to eval it
- * in. */
+ * in. */
int result; /* Result of call to eval script. */
- esPtr = (EventScriptRecord *) clientData;
- chanPtr = esPtr->chanPtr;
- mask = esPtr->mask;
- interp = esPtr->interp;
+ esPtr = clientData;
+ chanPtr = esPtr->chanPtr;
+ mask = esPtr->mask;
+ interp = esPtr->interp;
/*
- * We must preserve the interpreter so we can report errors on it
- * later. Note that we do not need to preserve the channel because
- * that is done by Tcl_NotifyChannel before calling channel handlers.
+ * We must preserve the interpreter so we can report errors on it later.
+ * Note that we do not need to preserve the channel because that is done
+ * by Tcl_NotifyChannel before calling channel handlers.
*/
-
- Tcl_Preserve((ClientData) interp);
+
+ Tcl_Preserve(interp);
result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL);
/*
- * On error, cause a background error and remove the channel handler
- * and the script record.
+ * On error, cause a background error and remove the channel handler and
+ * the script record.
*
* NOTE: Must delete channel handler before causing the background error
* because the background error may want to reinstall the handler.
*/
-
+
if (result != TCL_OK) {
if (chanPtr->typePtr != NULL) {
DeleteScriptRecord(interp, chanPtr, mask);
}
- Tcl_BackgroundError(interp);
+ TclBackgroundException(interp, result);
}
- Tcl_Release((ClientData) interp);
+ Tcl_Release(interp);
}
/*
@@ -7564,10 +8371,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.
@@ -7580,22 +8387,20 @@ TclChannelEventScriptInvoker(clientData, mask)
/* ARGSUSED */
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. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
-{
- Channel *chanPtr; /* The channel to create
- * the handler for. */
- ChannelState *statePtr; /* state info for channel */
- Tcl_Channel chan; /* The opaque type for the channel. */
+Tcl_FileEventObjCmd(
+ ClientData clientData, /* Not used. */
+ Tcl_Interp *interp, /* Interpreter in which the channel for which
+ * to create the handler is found. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *const objv[]) /* Argument objects. */
+{
+ Channel *chanPtr; /* The channel to create the handler for. */
+ ChannelState *statePtr; /* State info for channel */
+ Tcl_Channel chan; /* The opaque type for the channel. */
char *chanName;
- int modeIndex; /* Index of mode argument. */
+ int modeIndex; /* Index of mode argument. */
int mask;
- static CONST char *modeOptions[] = {"readable", "writable", NULL};
+ static const char *modeOptions[] = {"readable", "writable", NULL};
static int maskArray[] = {TCL_READABLE, TCL_WRITABLE};
if ((objc != 3) && (objc != 4)) {
@@ -7608,85 +8413,110 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
}
mask = maskArray[modeIndex];
- chanName = Tcl_GetString(objv[1]);
+ chanName = TclGetString(objv[1]);
chan = Tcl_GetChannel(interp, chanName, NULL);
- if (chan == (Tcl_Channel) NULL) {
+ if (chan == NULL) {
return TCL_ERROR;
}
- chanPtr = (Channel *) chan;
+ chanPtr = (Channel *) chan;
statePtr = chanPtr->state;
if ((statePtr->flags & mask) == 0) {
- Tcl_AppendResult(interp, "channel is not ",
- (mask == TCL_READABLE) ? "readable" : "writable",
- (char *) NULL);
- return TCL_ERROR;
+ Tcl_AppendResult(interp, "channel is not ",
+ (mask == TCL_READABLE) ? "readable" : "writable", NULL);
+ return TCL_ERROR;
}
-
+
/*
* If we are supposed to return the script, do so.
*/
if (objc == 3) {
EventScriptRecord *esPtr;
- for (esPtr = statePtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
- esPtr = esPtr->nextPtr) {
+ for (esPtr = statePtr->scriptRecordPtr; esPtr != NULL;
+ esPtr = esPtr->nextPtr) {
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
Tcl_SetObjResult(interp, esPtr->scriptPtr);
break;
}
}
- return TCL_OK;
+ return TCL_OK;
}
/*
* If we are supposed to delete a stored script, do so.
*/
- if (*(Tcl_GetString(objv[3])) == '\0') {
- DeleteScriptRecord(interp, chanPtr, mask);
- return TCL_OK;
+ if (*(TclGetString(objv[3])) == '\0') {
+ DeleteScriptRecord(interp, chanPtr, mask);
+ return TCL_OK;
}
/*
- * Make the script record that will link between the event and the
- * script to invoke. This also creates a channel event handler which
- * will evaluate the script in the supplied interpreter.
+ * Make the script record that will link between the event and the script
+ * to invoke. This also creates a channel event handler which will
+ * evaluate the script in the supplied interpreter.
*/
CreateScriptRecord(interp, chanPtr, mask, objv[3]);
-
+
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
+ * ZeroTransferTimerProc --
+ *
+ * Timer handler scheduled by TclCopyChannel so that -command is
+ * called asynchronously even when -size is 0.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Calls CopyData for -command invocation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ZeroTransferTimerProc(
+ ClientData clientData)
+{
+ /* calling CopyData with mask==0 still implies immediate invocation of the
+ * -command callback, and completion of the fcopy.
+ */
+ CopyData(clientData, 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
* TclCopyChannel --
*
* This routine copies data from one channel to another, either
- * synchronously or asynchronously. If a command script is
- * supplied, the operation runs in the background. The script
- * is invoked when the copy completes. Otherwise the function
- * waits until the copy is completed before returning.
+ * synchronously or asynchronously. If a command script is supplied, the
+ * operation runs in the background. The script is invoked when the copy
+ * completes. Otherwise the function waits until the copy is completed
+ * before returning.
*
* Results:
* A standard Tcl result.
*
* Side effects:
- * May schedule a background copy operation that causes both
- * channels to be marked busy.
+ * May schedule a background copy operation that causes both channels to
+ * be marked busy.
*
*----------------------------------------------------------------------
*/
int
-TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
- Tcl_Interp *interp; /* Current interpreter. */
- Tcl_Channel inChan; /* Channel to read from. */
- Tcl_Channel outChan; /* Channel to write to. */
- int toRead; /* Amount of data to copy, or -1 for all. */
- Tcl_Obj *cmdPtr; /* Pointer to script to execute or NULL. */
+TclCopyChannel(
+ Tcl_Interp *interp, /* Current interpreter. */
+ Tcl_Channel inChan, /* Channel to read from. */
+ Tcl_Channel outChan, /* Channel to write to. */
+ int toRead, /* Amount of data to copy, or -1 for all. */
+ Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */
{
Channel *inPtr = (Channel *) inChan;
Channel *outPtr = (Channel *) outChan;
@@ -7695,53 +8525,46 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
CopyState *csPtr;
int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
- inStatePtr = inPtr->state;
- outStatePtr = outPtr->state;
+ inStatePtr = inPtr->state;
+ outStatePtr = outPtr->state;
if (BUSY_STATE(inStatePtr,TCL_READABLE)) {
if (interp) {
- Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
+ Tcl_AppendResult(interp, "channel \"",
Tcl_GetChannelName(inChan), "\" is busy", NULL);
}
return TCL_ERROR;
}
if (BUSY_STATE(outStatePtr,TCL_WRITABLE)) {
if (interp) {
- Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
+ Tcl_AppendResult(interp, "channel \"",
Tcl_GetChannelName(outChan), "\" is busy", NULL);
}
return TCL_ERROR;
}
- readFlags = inStatePtr->flags;
- writeFlags = outStatePtr->flags;
+ readFlags = inStatePtr->flags;
+ writeFlags = outStatePtr->flags;
/*
- * Set up the blocking mode appropriately. Background copies need
- * non-blocking channels. Foreground copies need blocking channels.
- * If there is an error, restore the old blocking mode.
+ * Set up the blocking mode appropriately. Background copies need
+ * non-blocking channels. Foreground copies need blocking channels. If
+ * there is an error, restore the old blocking mode.
*/
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
- if (SetBlockMode(interp, inPtr,
- nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
- != TCL_OK) {
+ if (SetBlockMode(interp, inPtr, nonBlocking ?
+ TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) {
return TCL_ERROR;
}
- }
- if (inPtr != outPtr) {
- if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) {
- if (SetBlockMode(NULL, outPtr,
- nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
- != TCL_OK) {
- if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
- SetBlockMode(NULL, inPtr,
- (readFlags & CHANNEL_NONBLOCKING)
- ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
- return TCL_ERROR;
- }
- }
- }
+ }
+ if ((inPtr!=outPtr) && (nonBlocking!=(writeFlags&CHANNEL_NONBLOCKING)) &&
+ (SetBlockMode(NULL, outPtr, nonBlocking ?
+ TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) &&
+ (nonBlocking != (readFlags & CHANNEL_NONBLOCKING))) {
+ SetBlockMode(NULL, inPtr, (readFlags & CHANNEL_NONBLOCKING)
+ ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
+ return TCL_ERROR;
}
/*
@@ -7753,19 +8576,19 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
/*
* Allocate a new CopyState to maintain info about the current copy in
- * progress. This structure will be deallocated when the copy is
+ * progress. This structure will be deallocated when the copy is
* completed.
*/
- csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inStatePtr->bufSize);
- csPtr->bufSize = inStatePtr->bufSize;
- csPtr->readPtr = inPtr;
- csPtr->writePtr = outPtr;
- csPtr->readFlags = readFlags;
+ csPtr = (CopyState *) ckalloc(sizeof(CopyState) + inStatePtr->bufSize);
+ csPtr->bufSize = inStatePtr->bufSize;
+ csPtr->readPtr = inPtr;
+ csPtr->writePtr = outPtr;
+ csPtr->readFlags = readFlags;
csPtr->writeFlags = writeFlags;
- csPtr->toRead = toRead;
- csPtr->total = 0;
- csPtr->interp = interp;
+ csPtr->toRead = toRead;
+ csPtr->total = 0;
+ csPtr->interp = interp;
if (cmdPtr) {
Tcl_IncrRefCount(cmdPtr);
}
@@ -7775,6 +8598,16 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
outStatePtr->csPtrW = csPtr;
/*
+ * Special handling of -size 0 async transfers, so that the -command is
+ * still called asynchronously.
+ */
+
+ if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) {
+ Tcl_CreateTimerHandler(0, ZeroTransferTimerProc, csPtr);
+ return 0;
+ }
+
+ /*
* Start copying data between the channels.
*/
@@ -7786,8 +8619,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.
@@ -7799,19 +8632,20 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
*/
static int
-CopyData(csPtr, mask)
- CopyState *csPtr; /* State of copy operation. */
- int mask; /* Current channel event flags. */
+CopyData(
+ CopyState *csPtr, /* State of copy operation. */
+ int mask) /* Current channel event flags. */
{
Tcl_Interp *interp;
- Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL;
+ Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
Tcl_Channel inChan, outChan;
ChannelState *inStatePtr, *outStatePtr;
- int result = TCL_OK, size, total, sizeb;
- char* buffer;
-
- int inBinary, outBinary, sameEncoding; /* Encoding control */
- int underflow; /* input underflow */
+ int result = TCL_OK, size, sizeb;
+ Tcl_WideInt total;
+ char *buffer;
+ int inBinary, outBinary, sameEncoding;
+ /* Encoding control */
+ int underflow; /* Input underflow */
inChan = (Tcl_Channel) csPtr->readPtr;
outChan = (Tcl_Channel) csPtr->writePtr;
@@ -7823,18 +8657,18 @@ 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);
- outBinary = (outStatePtr->encoding == NULL);
- sameEncoding = (inStatePtr->encoding == outStatePtr->encoding);
+ inBinary = (inStatePtr->encoding == NULL);
+ outBinary = (outStatePtr->encoding == NULL);
+ sameEncoding = (inStatePtr->encoding == outStatePtr->encoding);
if (!(inBinary || sameEncoding)) {
- bufObj = Tcl_NewObj ();
- Tcl_IncrRefCount (bufObj);
+ TclNewObj(bufObj);
+ Tcl_IncrRefCount(bufObj);
}
while (csPtr->toRead != 0) {
@@ -7842,17 +8676,19 @@ CopyData(csPtr, mask)
* Check for unreported background errors.
*/
- if (inStatePtr->unreportedError != 0) {
+ Tcl_GetChannelError(inChan, &msg);
+ if ((inStatePtr->unreportedError != 0) || (msg != NULL)) {
Tcl_SetErrno(inStatePtr->unreportedError);
inStatePtr->unreportedError = 0;
goto readError;
}
- if (outStatePtr->unreportedError != 0) {
+ Tcl_GetChannelError(outChan, &msg);
+ if ((outStatePtr->unreportedError != 0) || (msg != NULL)) {
Tcl_SetErrno(outStatePtr->unreportedError);
outStatePtr->unreportedError = 0;
goto writeError;
}
-
+
if (cmdPtr && (mask == 0)) {
/*
* In async mode, we skip reading synchronously and fake an
@@ -7867,51 +8703,60 @@ CopyData(csPtr, mask)
*/
if ((csPtr->toRead == -1) || (csPtr->toRead > csPtr->bufSize)) {
- sizeb = csPtr->bufSize;
+ sizeb = csPtr->bufSize;
} else {
- sizeb = csPtr->toRead;
+ sizeb = csPtr->toRead;
}
if (inBinary || sameEncoding) {
- size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb);
+ size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb);
} else {
- size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, 0 /* No append */);
+ size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
+ 0 /* No append */);
}
- underflow = (size >= 0) && (size < sizeb); /* input underflow */
+ underflow = (size >= 0) && (size < sizeb); /* Input underflow */
}
if (size < 0) {
- readError:
- errObj = Tcl_NewObj();
- Tcl_AppendStringsToObj(errObj, "error reading \"",
- Tcl_GetChannelName(inChan), "\": ",
- Tcl_PosixError(interp), (char *) NULL);
+ readError:
+ if (interp) {
+ TclNewObj(errObj);
+ Tcl_AppendStringsToObj(errObj, "error reading \"",
+ Tcl_GetChannelName(inChan), "\": ", NULL);
+ if (msg != NULL) {
+ Tcl_AppendObjToObj(errObj, msg);
+ } else {
+ Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp),
+ NULL);
+ }
+ }
+ if (msg != NULL) {
+ Tcl_DecrRefCount(msg);
+ }
break;
} else if (underflow) {
/*
- * We had an underflow on the read side. If we are at
- * EOF, and not in the synchronous part of an asynchronous
- * fcopy, then the copying is done, otherwise set up a
- * channel handler to detect when the channel becomes
- * readable again.
+ * We had an underflow on the read side. If we are at EOF, and not
+ * in the synchronous part of an asynchronous fcopy, then the
+ * copying is done, otherwise set up a channel handler to detect
+ * when the channel becomes readable again.
*/
-
+
if ((size == 0) && Tcl_Eof(inChan) && !(cmdPtr && (mask == 0))) {
break;
}
if (((!Tcl_Eof(inChan)) || (cmdPtr && (mask == 0))) &&
!(mask & TCL_READABLE)) {
if (mask & TCL_WRITABLE) {
- Tcl_DeleteChannelHandler(outChan, CopyEventProc,
- (ClientData) csPtr);
+ Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr);
}
- Tcl_CreateChannelHandler(inChan, TCL_READABLE,
- CopyEventProc, (ClientData) csPtr);
+ Tcl_CreateChannelHandler(inChan, TCL_READABLE, CopyEventProc,
+ csPtr);
}
if (size == 0) {
- if (bufObj != (Tcl_Obj*) NULL) {
- Tcl_DecrRefCount (bufObj);
- bufObj = (Tcl_Obj*) NULL;
+ if (bufObj != NULL) {
+ TclDecrRefCount(bufObj);
+ bufObj = NULL;
}
return TCL_OK;
}
@@ -7925,7 +8770,7 @@ CopyData(csPtr, mask)
buffer = csPtr->buffer;
sizeb = size;
} else {
- buffer = Tcl_GetStringFromObj (bufObj, &sizeb);
+ buffer = TclGetStringFromObj(bufObj, &sizeb);
}
if (outBinary || sameEncoding) {
@@ -7947,19 +8792,29 @@ CopyData(csPtr, mask)
*/
if (sizeb < 0) {
- writeError:
- errObj = Tcl_NewObj();
- Tcl_AppendStringsToObj(errObj, "error writing \"",
- Tcl_GetChannelName(outChan), "\": ",
- Tcl_PosixError(interp), (char *) NULL);
+ writeError:
+ if (interp) {
+ TclNewObj(errObj);
+ Tcl_AppendStringsToObj(errObj, "error writing \"",
+ Tcl_GetChannelName(outChan), "\": ", NULL);
+ if (msg != NULL) {
+ Tcl_AppendObjToObj(errObj, msg);
+ } else {
+ Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp),
+ NULL);
+ }
+ }
+ if (msg != NULL) {
+ Tcl_DecrRefCount(msg);
+ }
break;
}
/*
- * Update the current byte count. Do it now so the count is
- * valid before a return or break takes us out of the loop.
- * The invariant at the top of the loop should be that
- * csPtr->toRead holds the number of bytes left to copy.
+ * (UP) 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) {
@@ -7971,89 +8826,90 @@ CopyData(csPtr, mask)
* Break loop if EOF && (size>0)
*/
- if (Tcl_Eof(inChan)) {
- break;
- }
+ if (Tcl_Eof(inChan)) {
+ break;
+ }
/*
- * Check to see if the write is happening in the background. If so,
+ * Check to see if the write is happening in the background. If so,
* stop copying and wait for the channel to become writable again.
* After input underflow we already installed a readable handler
* therefore we don't need a writable handler.
*/
- if ( ! underflow && (outStatePtr->flags & BG_FLUSH_SCHEDULED) ) {
+ if (!underflow && (outStatePtr->flags & BG_FLUSH_SCHEDULED)) {
if (!(mask & TCL_WRITABLE)) {
if (mask & TCL_READABLE) {
- Tcl_DeleteChannelHandler(inChan, CopyEventProc,
- (ClientData) csPtr);
+ Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr);
}
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
- CopyEventProc, (ClientData) csPtr);
+ CopyEventProc, csPtr);
}
- if (bufObj != (Tcl_Obj*) NULL) {
- Tcl_DecrRefCount (bufObj);
- bufObj = (Tcl_Obj*) NULL;
+ if (bufObj != NULL) {
+ TclDecrRefCount(bufObj);
+ bufObj = NULL;
}
return TCL_OK;
}
/*
- * For background copies, we only do one buffer per invocation so
- * we don't starve the rest of the system.
+ * For background copies, we only do one buffer per invocation so we
+ * don't starve the rest of the system.
*/
if (cmdPtr && (csPtr->toRead != 0)) {
/*
- * The first time we enter this code, there won't be a
- * channel handler established yet, so do it here.
+ * The first time we enter this code, there won't be a channel
+ * handler established yet, so do it here.
*/
if (mask == 0) {
- Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
- CopyEventProc, (ClientData) csPtr);
+ Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc,
+ csPtr);
}
- if (bufObj != (Tcl_Obj*) NULL) {
- Tcl_DecrRefCount (bufObj);
- bufObj = (Tcl_Obj*) NULL;
+ if (bufObj != NULL) {
+ TclDecrRefCount(bufObj);
+ bufObj = NULL;
}
return TCL_OK;
}
} /* while */
- if (bufObj != (Tcl_Obj*) NULL) {
- Tcl_DecrRefCount (bufObj);
- bufObj = (Tcl_Obj*) NULL;
+ if (bufObj != NULL) {
+ TclDecrRefCount(bufObj);
+ bufObj = NULL;
}
/*
- * Make the callback or return the number of bytes transferred.
- * The local total is used because StopCopy frees csPtr.
+ * Make the callback or return the number of bytes transferred. The local
+ * total is used because StopCopy frees csPtr.
*/
total = csPtr->total;
if (cmdPtr && interp) {
+ int code;
/*
- * Get a private copy of the command so we can mutate it
- * by adding arguments. Note that StopCopy frees our saved
- * reference to the original command obj.
+ * Get a private copy of the command so we can mutate it by adding
+ * arguments. Note that StopCopy frees our saved reference to the
+ * original command obj.
*/
cmdPtr = Tcl_DuplicateObj(cmdPtr);
Tcl_IncrRefCount(cmdPtr);
StopCopy(csPtr);
- Tcl_Preserve((ClientData) interp);
+ Tcl_Preserve(interp);
- Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewIntObj(total));
+ Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewWideIntObj(total));
if (errObj) {
Tcl_ListObjAppendElement(interp, cmdPtr, errObj);
}
- if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
- Tcl_BackgroundError(interp);
+ code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL);
+ if (code != TCL_OK) {
+ TclBackgroundException(interp, code);
result = TCL_ERROR;
}
- Tcl_DecrRefCount(cmdPtr);
- Tcl_Release((ClientData) interp);
+ TclDecrRefCount(cmdPtr);
+ Tcl_Release(interp);
} else {
StopCopy(csPtr);
if (interp) {
@@ -8062,7 +8918,7 @@ CopyData(csPtr, mask)
result = TCL_ERROR;
} else {
Tcl_ResetResult(interp);
- Tcl_SetIntObj(Tcl_GetObjResult(interp), total);
+ Tcl_SetObjResult(interp, Tcl_NewWideIntObj(total));
}
}
}
@@ -8079,8 +8935,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.
@@ -8089,60 +8945,61 @@ CopyData(csPtr, mask)
*/
static int
-DoRead(chanPtr, bufPtr, toRead)
- Channel *chanPtr; /* The channel from which to read. */
- char *bufPtr; /* Where to store input read. */
- int toRead; /* Maximum number of bytes to read. */
-{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
- int copied; /* How many characters were copied into
- * the result string? */
- int copiedNow; /* How many characters were copied from
- * the current input buffer? */
+DoRead(
+ Channel *chanPtr, /* The channel from which to read. */
+ char *bufPtr, /* Where to store input read. */
+ int toRead) /* Maximum number of bytes to read. */
+{
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ int copied; /* How many characters were copied into the
+ * result string? */
+ int copiedNow; /* How many characters were copied from the
+ * current input buffer? */
int result; /* Of calling GetInput. */
/*
- * If we have not encountered a sticky EOF, clear the EOF bit. Either
- * way clear the BLOCKED bit. We want to discover these anew during
- * each operation.
+ * If we have not encountered a sticky EOF, clear the EOF bit. Either way
+ * clear the BLOCKED bit. We want to discover these anew during each
+ * operation.
*/
if (!(statePtr->flags & CHANNEL_STICKY_EOF)) {
- statePtr->flags &= ~CHANNEL_EOF;
+ ResetFlag(statePtr, CHANNEL_EOF);
}
- statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
-
+ ResetFlag(statePtr, CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+
for (copied = 0; copied < toRead; copied += copiedNow) {
- copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied,
- toRead - copied);
- if (copiedNow == 0) {
- if (statePtr->flags & CHANNEL_EOF) {
+ copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied,
+ toRead - copied);
+ if (copiedNow == 0) {
+ if (statePtr->flags & CHANNEL_EOF) {
goto done;
- }
- if (statePtr->flags & CHANNEL_BLOCKED) {
- if (statePtr->flags & CHANNEL_NONBLOCKING) {
+ }
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
goto done;
- }
- statePtr->flags &= (~(CHANNEL_BLOCKED));
- }
- result = GetInput(chanPtr);
- if (result != 0) {
- if (result != EAGAIN) {
- copied = -1;
- }
+ }
+ ResetFlag(statePtr, CHANNEL_BLOCKED);
+ }
+ result = GetInput(chanPtr);
+ if (result != 0) {
+ if (result != EAGAIN) {
+ copied = -1;
+ }
goto done;
- }
- }
+ }
+ }
}
- statePtr->flags &= (~(CHANNEL_BLOCKED));
+ ResetFlag(statePtr, 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;
}
@@ -8152,13 +9009,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.
@@ -8167,220 +9024,208 @@ DoRead(chanPtr, bufPtr, toRead)
*/
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? */
+CopyAndTranslateBuffer(
+ ChannelState *statePtr, /* Channel state from which to read input. */
+ char *result, /* Where to store the copied input. */
+ int space) /* How many bytes are available in result to
+ * store the copied input? */
{
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
- int bytesInBuffer; /* How many bytes are available to be
- * copied in the current input buffer? */
+ int bytesInBuffer; /* How many bytes are available to be copied
+ * in the current input buffer? */
int copied; /* How many characters were already copied
- * into the destination space? */
- int i; /* Iterates over the copied input looking
- * for the input eofChar. */
-
+ * into the destination space? */
+ int i; /* Iterates over the copied input looking for
+ * the input eofChar. */
+
/*
* If there is no input at all, return zero. The invariant is that either
- * there is no buffer in the queue, or if the first buffer is empty, it
- * is also the last buffer (and thus there is no input in the queue).
- * Note also that if the buffer is empty, we leave it in the queue.
+ * there is no buffer in the queue, or if the first buffer is empty, it is
+ * also the last buffer (and thus there is no input in the queue). Note
+ * also that if the buffer is empty, we leave it in the queue.
*/
-
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- return 0;
+
+ if (statePtr->inQueueHead == NULL) {
+ return 0;
}
bufPtr = statePtr->inQueueHead;
- bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
+ bytesInBuffer = BytesLeft(bufPtr);
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.
- */
-
- if (bytesInBuffer < space) {
- space = bytesInBuffer;
- }
- 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;
- }
+ /*
+ * Copy the current chunk into the result buffer.
+ */
- /*
- * Copy the current chunk into the result buffer, then
- * replace all \r with \n.
- */
-
- if (bytesInBuffer < space) {
- space = bytesInBuffer;
- }
- memcpy((VOID *) result,
- (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
- bufPtr->nextRemoved += space;
- copied = space;
-
- for (end = result + copied; result < end; result++) {
- if (*result == '\r') {
- *result = '\n';
- }
- }
- break;
- }
- case TCL_TRANSLATE_CRLF: {
- char *src, *end, *dst;
- int curByte;
-
- /*
- * If there is a held-back "\r" at EOF, produce it now.
- */
-
- if (bytesInBuffer == 0) {
- if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
- (INPUT_SAW_CR | CHANNEL_EOF)) {
- result[0] = '\r';
- statePtr->flags &= ~INPUT_SAW_CR;
- return 1;
- }
- return 0;
- }
-
- /*
- * Copy the current chunk and replace "\r\n" with "\n"
- * (but not standalone "\r"!).
- */
-
- if (bytesInBuffer < space) {
- space = bytesInBuffer;
- }
- memcpy((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 (bytesInBuffer < space) {
+ space = bytesInBuffer;
+ }
+ memcpy(result, RemovePoint(bufPtr), (size_t) space);
+ bufPtr->nextRemoved += space;
+ copied = space;
+ break;
+ case TCL_TRANSLATE_CR: {
+ char *end;
+
+ if (bytesInBuffer == 0) {
+ return 0;
+ }
+
+ /*
+ * Copy the current chunk into the result buffer, then replace all \r
+ * with \n.
+ */
+
+ if (bytesInBuffer < space) {
+ space = bytesInBuffer;
+ }
+ memcpy(result, RemovePoint(bufPtr), (size_t) space);
+ bufPtr->nextRemoved += space;
+ copied = space;
+
+ for (end = result + copied; result < end; result++) {
+ if (*result == '\r') {
+ *result = '\n';
}
- copied = dst - result;
- break;
}
- case TCL_TRANSLATE_AUTO: {
- char *src, *end, *dst;
- int curByte;
-
- if (bytesInBuffer == 0) {
- return 0;
- }
-
- /*
- * Loop over the current buffer, converting "\r" and "\r\n"
- * to "\n".
- */
-
- 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';
+ break;
+ }
+ case TCL_TRANSLATE_CRLF: {
+ char *src, *end, *dst;
+ int curByte;
+
+ /*
+ * If there is a held-back "\r" at EOF, produce it now.
+ */
+
+ if (bytesInBuffer == 0) {
+ if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
+ (INPUT_SAW_CR | CHANNEL_EOF)) {
+ result[0] = '\r';
+ ResetFlag(statePtr, INPUT_SAW_CR);
+ return 1;
+ }
+ return 0;
+ }
+
+ /*
+ * Copy the current chunk and replace "\r\n" with "\n" (but not
+ * standalone "\r"!).
+ */
+
+ if (bytesInBuffer < space) {
+ space = bytesInBuffer;
+ }
+ memcpy(result, RemovePoint(bufPtr), (size_t) space);
+ bufPtr->nextRemoved += space;
+ copied = space;
+
+ end = result + copied;
+ dst = result;
+ for (src = result; src < end; src++) {
+ curByte = *src;
+ if (curByte == '\n') {
+ ResetFlag(statePtr, INPUT_SAW_CR);
+ } else if (statePtr->flags & INPUT_SAW_CR) {
+ ResetFlag(statePtr, INPUT_SAW_CR);
+ *dst = '\r';
+ dst++;
+ }
+ if (curByte == '\r') {
+ SetFlag(statePtr, INPUT_SAW_CR);
+ } else {
+ *dst = (char) curByte;
+ dst++;
+ }
+ }
+ copied = dst - result;
+ break;
+ }
+ case TCL_TRANSLATE_AUTO: {
+ char *src, *end, *dst;
+ int curByte;
+
+ if (bytesInBuffer == 0) {
+ return 0;
+ }
+
+ /*
+ * Loop over the current buffer, converting "\r" and "\r\n" to "\n".
+ */
+
+ if (bytesInBuffer < space) {
+ space = bytesInBuffer;
+ }
+ memcpy(result, RemovePoint(bufPtr), (size_t) space);
+ bufPtr->nextRemoved += space;
+ copied = space;
+
+ end = result + copied;
+ dst = result;
+ for (src = result; src < end; src++) {
+ curByte = *src;
+ if (curByte == '\r') {
+ SetFlag(statePtr, INPUT_SAW_CR);
+ *dst = '\n';
+ dst++;
+ } else {
+ if ((curByte != '\n') || !(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;
}
+ ResetFlag(statePtr, INPUT_SAW_CR);
}
- copied = dst - result;
- break;
- }
- default: {
- panic("unknown eol translation mode");
}
+ copied = dst - result;
+ break;
+ }
+ default:
+ Tcl_Panic("unknown eol translation mode");
}
/*
- * If an in-stream EOF character is set for this channel, check that
- * the input we copied so far does not contain the EOF char. If it does,
- * copy only up to and excluding that character.
+ * If an in-stream EOF character is set for this channel, check that the
+ * input we copied so far does not contain the EOF char. If it does, copy
+ * only up to and excluding that character.
*/
-
+
if (statePtr->inEofChar != 0) {
- for (i = 0; i < copied; i++) {
- if (result[i] == (char) statePtr->inEofChar) {
+ for (i = 0; i < copied; i++) {
+ if (result[i] == (char) statePtr->inEofChar) {
/*
- * Set sticky EOF so that no further input is presented
- * to the caller.
+ * Set sticky EOF so that no further input is presented to the
+ * caller.
*/
-
- statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+
+ SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
copied = i;
- break;
- }
- }
+ break;
+ }
+ }
}
/*
* If the current buffer is empty recycle it.
*/
- if (bufPtr->nextRemoved == bufPtr->nextAdded) {
- statePtr->inQueueHead = bufPtr->nextPtr;
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
- }
- RecycleBuffer(statePtr, bufPtr, 0);
+ if (IsBufferEmpty(bufPtr)) {
+ statePtr->inQueueHead = bufPtr->nextPtr;
+ if (statePtr->inQueueHead == NULL) {
+ statePtr->inQueueTail = NULL;
+ }
+ RecycleBuffer(statePtr, bufPtr, 0);
}
/*
- * Return the number of characters copied into the result buffer.
- * This may be different from the number of bytes consumed, because
- * of EOL translations.
+ * Return the number of characters copied into the result buffer. This may
+ * be different from the number of bytes consumed, because of EOL
+ * translations.
*/
return copied;
@@ -8394,8 +9239,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.
@@ -8404,39 +9249,39 @@ CopyAndTranslateBuffer(statePtr, result, space)
*/
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? */
+CopyBuffer(
+ Channel *chanPtr, /* Channel from which to read input. */
+ char *result, /* Where to store the copied input. */
+ int space) /* How many bytes are available in result to
+ * store the copied input? */
{
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
- int bytesInBuffer; /* How many bytes are available to be
- * copied in the current input buffer? */
+ int bytesInBuffer; /* How many bytes are available to be copied
+ * in the current input buffer? */
int copied; /* How many characters were already copied
- * into the destination space? */
-
+ * into the destination space? */
+
/*
- * If there is no input at all, return zero. The invariant is that
- * either there is no buffer in the queue, or if the first buffer
- * is empty, it is also the last buffer (and thus there is no
- * input in the queue). Note also that if the buffer is empty, we
- * don't leave it in the queue, but recycle it.
+ * If there is no input at all, return zero. The invariant is that either
+ * there is no buffer in the queue, or if the first buffer is empty, it is
+ * also the last buffer (and thus there is no input in the queue). Note
+ * also that if the buffer is empty, we don't leave it in the queue, but
+ * recycle it.
*/
-
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
- return 0;
+
+ if (chanPtr->inQueueHead == NULL) {
+ return 0;
}
bufPtr = chanPtr->inQueueHead;
- bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
+ bytesInBuffer = BytesLeft(bufPtr);
copied = 0;
if (bytesInBuffer == 0) {
- RecycleBuffer(chanPtr->state, bufPtr, 0);
- chanPtr->inQueueHead = (ChannelBuffer*) NULL;
- chanPtr->inQueueTail = (ChannelBuffer*) NULL;
- return 0;
+ RecycleBuffer(chanPtr->state, bufPtr, 0);
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
+ return 0;
}
/*
@@ -8444,31 +9289,29 @@ CopyBuffer(chanPtr, result, space)
*/
if (bytesInBuffer < space) {
- space = bytesInBuffer;
+ space = bytesInBuffer;
}
- memcpy((VOID *) result,
- (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, RemovePoint(bufPtr), (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
/*
- * We don't care about in-stream EOF characters here as the data
- * read here may still flow through one or more transformations,
- * i.e. is not in its final state yet.
+ * We don't care about in-stream EOF characters here as the data read here
+ * may still flow through one or more transformations, i.e. is not in its
+ * final state yet.
*/
/*
* If the current buffer is empty recycle it.
*/
- if (bufPtr->nextRemoved == bufPtr->nextAdded) {
- chanPtr->inQueueHead = bufPtr->nextPtr;
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
- }
- RecycleBuffer(chanPtr->state, bufPtr, 0);
+ if (IsBufferEmpty(bufPtr)) {
+ chanPtr->inQueueHead = bufPtr->nextPtr;
+ if (chanPtr->inQueueHead == NULL) {
+ chanPtr->inQueueTail = NULL;
+ }
+ RecycleBuffer(chanPtr->state, bufPtr, 0);
}
/*
@@ -8500,29 +9343,28 @@ CopyBuffer(chanPtr, result, space)
*/
static int
-DoWrite(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* Data to write. */
- int srcLen; /* Number of bytes to write. */
-{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
- ChannelBuffer *outBufPtr; /* Current output buffer. */
- int foundNewline; /* Did we find a newline in output? */
+DoWrite(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ const char *src, /* Data to write. */
+ int srcLen) /* Number of bytes to write. */
+{
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ ChannelBuffer *outBufPtr; /* Current output buffer. */
+ int foundNewline; /* Did we find a newline in output? */
char *dPtr;
- CONST char *sPtr; /* Search variables for newline. */
- int crsent; /* In CRLF eol translation mode,
- * remember the fact that a CR was
- * output to the channel without
- * its following NL. */
- int i; /* Loop index for newline search. */
- int destCopied; /* How many bytes were used in this
- * destination buffer to hold the
- * output? */
- int totalDestCopied; /* How many bytes total were
- * copied to the channel buffer? */
- int srcCopied; /* How many bytes were copied from
- * the source string? */
- char *destPtr; /* Where in line to copy to? */
+ const char *sPtr; /* Search variables for newline. */
+ int crsent; /* In CRLF eol translation mode, remember the
+ * fact that a CR was output to the channel
+ * without its following NL. */
+ int i; /* Loop index for newline search. */
+ int destCopied; /* How many bytes were used in this
+ * destination buffer to hold the output? */
+ int totalDestCopied; /* How many bytes total were copied to the
+ * channel buffer? */
+ int srcCopied; /* How many bytes were copied from the source
+ * string? */
+ char *destPtr; /* Where in line to copy to? */
/*
* If we are in network (or windows) translation mode, record the fact
@@ -8530,7 +9372,7 @@ DoWrite(chanPtr, src, srcLen)
*/
crsent = 0;
-
+
/*
* Loop filling buffers and flushing them until all output has been
* consumed.
@@ -8540,97 +9382,96 @@ DoWrite(chanPtr, src, srcLen)
totalDestCopied = 0;
while (srcLen > 0) {
-
- /*
- * Make sure there is a current output buffer to accept output.
- */
-
- if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
- statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
- }
-
- outBufPtr = statePtr->curOutPtr;
-
- destCopied = outBufPtr->bufLength - outBufPtr->nextAdded;
- if (destCopied > srcLen) {
- destCopied = srcLen;
- }
-
- destPtr = outBufPtr->buf + outBufPtr->nextAdded;
- switch (statePtr->outputTranslation) {
- case TCL_TRANSLATE_LF:
- srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
- break;
- case TCL_TRANSLATE_CR:
- srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
- for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
- if (*dPtr == '\n') {
- *dPtr = '\r';
- }
- }
- break;
- case TCL_TRANSLATE_CRLF:
- for (srcCopied = 0, dPtr = destPtr, sPtr = src;
- dPtr < destPtr + destCopied;
- dPtr++, sPtr++, srcCopied++) {
- if (*sPtr == '\n') {
- if (crsent) {
- *dPtr = '\n';
- crsent = 0;
- } else {
- *dPtr = '\r';
- crsent = 1;
- sPtr--, srcCopied--;
- }
- } else {
- *dPtr = *sPtr;
- }
- }
- break;
- case TCL_TRANSLATE_AUTO:
- panic("Tcl_Write: AUTO output translation mode not supported");
- default:
- panic("Tcl_Write: unknown output translation mode");
- }
-
- /*
- * The current buffer is ready for output if it is full, or if it
- * contains a newline and this channel is line-buffered, or if it
- * contains any output and this channel is unbuffered.
- */
-
- outBufPtr->nextAdded += destCopied;
- if (!(statePtr->flags & BUFFER_READY)) {
- if (outBufPtr->nextAdded == outBufPtr->bufLength) {
- statePtr->flags |= BUFFER_READY;
- } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
- for (sPtr = src, i = 0, foundNewline = 0;
- (i < srcCopied) && (!foundNewline);
- i++, sPtr++) {
- if (*sPtr == '\n') {
- foundNewline = 1;
- break;
- }
- }
- if (foundNewline) {
- statePtr->flags |= BUFFER_READY;
- }
- } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
- statePtr->flags |= BUFFER_READY;
- }
- }
-
- totalDestCopied += srcCopied;
- src += srcCopied;
- srcLen -= srcCopied;
-
- if (statePtr->flags & BUFFER_READY) {
- if (FlushChannel(NULL, chanPtr, 0) != 0) {
- return -1;
- }
- }
+ /*
+ * Make sure there is a current output buffer to accept output.
+ */
+
+ if (statePtr->curOutPtr == NULL) {
+ statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
+ }
+
+ outBufPtr = statePtr->curOutPtr;
+
+ destCopied = SpaceLeft(outBufPtr);
+ if (destCopied > srcLen) {
+ destCopied = srcLen;
+ }
+
+ destPtr = InsertPoint(outBufPtr);
+ switch (statePtr->outputTranslation) {
+ case TCL_TRANSLATE_LF:
+ srcCopied = destCopied;
+ memcpy(destPtr, src, (size_t) destCopied);
+ break;
+ case TCL_TRANSLATE_CR:
+ srcCopied = destCopied;
+ memcpy(destPtr, src, (size_t) destCopied);
+ for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
+ if (*dPtr == '\n') {
+ *dPtr = '\r';
+ }
+ }
+ break;
+ case TCL_TRANSLATE_CRLF:
+ for (srcCopied = 0, dPtr = destPtr, sPtr = src;
+ dPtr < destPtr + destCopied;
+ dPtr++, sPtr++, srcCopied++) {
+ if (*sPtr == '\n') {
+ if (crsent) {
+ *dPtr = '\n';
+ crsent = 0;
+ } else {
+ *dPtr = '\r';
+ crsent = 1;
+ sPtr--, srcCopied--;
+ }
+ } else {
+ *dPtr = *sPtr;
+ }
+ }
+ break;
+ case TCL_TRANSLATE_AUTO:
+ Tcl_Panic("Tcl_Write: AUTO output translation mode not supported");
+ default:
+ Tcl_Panic("Tcl_Write: unknown output translation mode");
+ }
+
+ /*
+ * The current buffer is ready for output if it is full, or if it
+ * contains a newline and this channel is line-buffered, or if it
+ * contains any output and this channel is unbuffered.
+ */
+
+ outBufPtr->nextAdded += destCopied;
+ if (!(statePtr->flags & BUFFER_READY)) {
+ if (IsBufferFull(outBufPtr)) {
+ SetFlag(statePtr, BUFFER_READY);
+ } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
+ for (sPtr = src, i = 0, foundNewline = 0;
+ (i < srcCopied) && (!foundNewline);
+ i++, sPtr++) {
+ if (*sPtr == '\n') {
+ foundNewline = 1;
+ break;
+ }
+ }
+ if (foundNewline) {
+ SetFlag(statePtr, BUFFER_READY);
+ }
+ } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
+ SetFlag(statePtr, BUFFER_READY);
+ }
+ }
+
+ totalDestCopied += srcCopied;
+ src += srcCopied;
+ srcLen -= srcCopied;
+
+ if (statePtr->flags & BUFFER_READY) {
+ if (FlushChannel(NULL, chanPtr, 0) != 0) {
+ return -1;
+ }
+ }
} /* Closes "while" */
return totalDestCopied;
@@ -8641,9 +9482,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.
@@ -8655,11 +9496,11 @@ DoWrite(chanPtr, src, srcLen)
*/
static void
-CopyEventProc(clientData, mask)
- ClientData clientData;
- int mask;
+CopyEventProc(
+ ClientData clientData,
+ int mask)
{
- (void) CopyData((CopyState *)clientData, mask);
+ (void) CopyData((CopyState *) clientData, mask);
}
/*
@@ -8673,15 +9514,15 @@ 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.
*
*----------------------------------------------------------------------
*/
static void
-StopCopy(csPtr)
- CopyState *csPtr; /* State for bg copy to stop . */
+StopCopy(
+ CopyState *csPtr) /* State for bg copy to stop . */
{
ChannelState *inStatePtr, *outStatePtr;
int nonBlocking;
@@ -8690,8 +9531,8 @@ StopCopy(csPtr)
return;
}
- inStatePtr = csPtr->readPtr->state;
- outStatePtr = csPtr->writePtr->state;
+ inStatePtr = csPtr->readPtr->state;
+ outStatePtr = csPtr->writePtr->state;
/*
* Restore the old blocking mode and output buffering mode.
@@ -8711,20 +9552,20 @@ 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,
+ csPtr);
if (csPtr->readPtr != csPtr->writePtr) {
- Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr,
- CopyEventProc, (ClientData)csPtr);
+ Tcl_DeleteChannelHandler((Tcl_Channel) csPtr->writePtr,
+ CopyEventProc, csPtr);
}
- Tcl_DecrRefCount(csPtr->cmdPtr);
+ TclDecrRefCount(csPtr->cmdPtr);
}
- inStatePtr->csPtrR = NULL;
+ inStatePtr->csPtrR = NULL;
outStatePtr->csPtrW = NULL;
- ckfree((char*) csPtr);
+ ckfree((char *) csPtr);
}
/*
@@ -8732,23 +9573,23 @@ 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.
*
*----------------------------------------------------------------------
*/
static int
-StackSetBlockMode(chanPtr, mode)
- Channel *chanPtr; /* Channel to modify. */
- int mode; /* One of TCL_MODE_BLOCKING or
+StackSetBlockMode(
+ Channel *chanPtr, /* Channel to modify. */
+ int mode) /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
int result = 0;
@@ -8759,7 +9600,7 @@ StackSetBlockMode(chanPtr, mode)
*/
chanPtr = chanPtr->state->topChanPtr;
- while (chanPtr != (Channel *) NULL) {
+ while (chanPtr != NULL) {
blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
if (blockModeProc != NULL) {
result = (*blockModeProc) (chanPtr->instanceData, mode);
@@ -8778,41 +9619,64 @@ 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.
*
*----------------------------------------------------------------------
*/
static int
-SetBlockMode(interp, chanPtr, mode)
- Tcl_Interp *interp; /* Interp for error reporting. */
- Channel *chanPtr; /* Channel to modify. */
- int mode; /* One of TCL_MODE_BLOCKING or
+SetBlockMode(
+ Tcl_Interp *interp, /* Interp for error reporting. */
+ Channel *chanPtr, /* Channel to modify. */
+ int mode) /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
int result = 0;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
result = StackSetBlockMode(chanPtr, mode);
if (result != 0) {
- if (interp != (Tcl_Interp *) NULL) {
- Tcl_AppendResult(interp, "error setting blocking mode: ",
- Tcl_PosixError(interp), (char *) NULL);
+ if (interp != NULL) {
+ /*
+ * TIP #219.
+ * Move error messages put by the driver into the bypass area and
+ * put them into the regular interpreter result. Fall back to the
+ * regular message if nothing was found in the bypass.
+ *
+ * Note that we cannot have a message in the interpreter bypass
+ * area, StackSetBlockMode is restricted to the channel bypass.
+ * We still need the interp as the destination of the move.
+ */
+
+ if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
+ Tcl_AppendResult(interp, "error setting blocking mode: ",
+ Tcl_PosixError(interp), NULL);
+ }
+ } else {
+ /*
+ * TIP #219.
+ * If we have no interpreter to put a bypass message into we have
+ * to clear it, to prevent its propagation and use in other places
+ * unrelated to the actual occurence of the problem.
+ */
+
+ Tcl_SetChannelError((Tcl_Channel) chanPtr, NULL);
}
return TCL_ERROR;
}
if (mode == TCL_MODE_BLOCKING) {
- statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
+ ResetFlag(statePtr, CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED);
} else {
- statePtr->flags |= CHANNEL_NONBLOCKING;
+ SetFlag(statePtr, CHANNEL_NONBLOCKING);
}
return TCL_OK;
}
@@ -8834,10 +9698,10 @@ SetBlockMode(interp, chanPtr, mode)
*/
int
-Tcl_GetChannelNames(interp)
- Tcl_Interp *interp; /* Interp for error reporting. */
+Tcl_GetChannelNames(
+ Tcl_Interp *interp) /* Interp for error reporting. */
{
- return Tcl_GetChannelNamesEx(interp, (char *) NULL);
+ return Tcl_GetChannelNamesEx(interp, NULL);
}
/*
@@ -8845,9 +9709,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.
@@ -8859,35 +9723,44 @@ Tcl_GetChannelNames(interp)
*/
int
-Tcl_GetChannelNamesEx(interp, pattern)
- Tcl_Interp *interp; /* Interp for error reporting. */
- CONST char *pattern; /* pattern to filter on. */
+Tcl_GetChannelNamesEx(
+ Tcl_Interp *interp, /* Interp for error reporting. */
+ const char *pattern) /* Pattern to filter on. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelState *statePtr;
- CONST char *name; /* name for channel */
- Tcl_Obj *resultPtr; /* pointer to result object */
+ const char *name; /* Name for channel */
+ Tcl_Obj *resultPtr; /* Pointer to result object */
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
Tcl_HashSearch hSearch; /* Search variable. */
- if (interp == (Tcl_Interp *) NULL) {
+ if (interp == NULL) {
return TCL_OK;
}
/*
- * Get the channel table that stores the channels registered
- * for this interpreter.
+ * Get the channel table that stores the channels registered for this
+ * interpreter.
*/
- hTblPtr = GetChannelTable(interp);
- resultPtr = Tcl_GetObjResult(interp);
- for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
- hPtr != (Tcl_HashEntry *) NULL;
- hPtr = Tcl_NextHashEntry(&hSearch)) {
+ hTblPtr = GetChannelTable(interp);
+ TclNewObj(resultPtr);
+ if ((pattern != NULL) && TclMatchIsTrivial(pattern)
+ && !((pattern[0] == 's') && (pattern[1] == 't')
+ && (pattern[2] == 'd'))) {
+ if ((Tcl_FindHashEntry(hTblPtr, pattern) != NULL)
+ && (Tcl_ListObjAppendElement(interp, resultPtr,
+ Tcl_NewStringObj(pattern, -1)) != TCL_OK)) {
+ goto error;
+ }
+ goto done;
+ }
+ for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
+ hPtr = Tcl_NextHashEntry(&hSearch)) {
statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state;
- if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
+ if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
name = "stdin";
} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
name = "stdout";
@@ -8895,18 +9768,24 @@ 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;
}
if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) &&
(Tcl_ListObjAppendElement(interp, resultPtr,
Tcl_NewStringObj(name, -1)) != TCL_OK)) {
+ error:
+ TclDecrRefCount(resultPtr);
return TCL_ERROR;
}
}
+
+ done:
+ Tcl_SetObjResult(interp, resultPtr);
return TCL_OK;
}
@@ -8915,8 +9794,8 @@ Tcl_GetChannelNamesEx(interp, pattern)
*
* 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.
@@ -8928,32 +9807,33 @@ Tcl_GetChannelNamesEx(interp, pattern)
*/
int
-Tcl_IsChannelRegistered (interp, chan)
- Tcl_Interp* interp; /* The interp to query of the channel */
- Tcl_Channel chan; /* The channel to check */
+Tcl_IsChannelRegistered(
+ Tcl_Interp *interp, /* The interp to query of the channel */
+ Tcl_Channel chan) /* The channel to check */
{
- Tcl_HashTable *hTblPtr; /* Hash table of channels. */
- Tcl_HashEntry *hPtr; /* Search variable. */
- Channel *chanPtr; /* The real IO channel. */
- ChannelState *statePtr; /* State of the real channel. */
+ Tcl_HashTable *hTblPtr; /* Hash table of channels. */
+ Tcl_HashEntry *hPtr; /* Search variable. */
+ Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of the real channel. */
/*
- * Always check bottom-most channel in the stack. This is the one
- * that gets registered.
+ * Always check bottom-most channel in the stack. This is the one that
+ * gets registered.
*/
+
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
- return 0;
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+ if (hTblPtr == NULL) {
+ return 0;
}
hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
- if (hPtr == (Tcl_HashEntry *) NULL) {
- return 0;
+ if (hPtr == NULL) {
+ return 0;
}
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
- return 0;
+ return 0;
}
return 1;
@@ -8976,11 +9856,11 @@ Tcl_IsChannelRegistered (interp, chan)
*/
int
-Tcl_IsChannelShared (chan)
- Tcl_Channel chan; /* The channel to query */
+Tcl_IsChannelShared(
+ Tcl_Channel chan) /* The channel to query */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return ((statePtr->refCount > 1) ? 1 : 0);
}
@@ -8991,8 +9871,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).
@@ -9004,19 +9884,18 @@ Tcl_IsChannelShared (chan)
*/
int
-Tcl_IsChannelExisting(chanName)
- CONST char* chanName; /* The name of the channel to look for. */
+Tcl_IsChannelExisting(
+ const char *chanName) /* The name of the channel to look for. */
{
ChannelState *statePtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- CONST char *name;
+ const char *name;
int chanNameLen;
chanNameLen = strlen(chanName);
- for (statePtr = tsdPtr->firstCSPtr;
- statePtr != NULL;
- statePtr = statePtr->nextCSPtr) {
- if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
+ for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL;
+ statePtr = statePtr->nextCSPtr) {
+ if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
name = "stdin";
} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
name = "stdout";
@@ -9026,7 +9905,8 @@ Tcl_IsChannelExisting(chanName)
name = statePtr->channelName;
}
- /* Bug 2333466. Include \0 in the compare to prevent partial matching on prefixes.
+ /* Bug 2333466. Include \0 in the compare to prevent partial matching
+ * on prefixes.
*/
if ((*chanName == *name) &&
(memcmp(name, chanName, (size_t) chanNameLen+1) == 0)) {
@@ -9053,9 +9933,9 @@ Tcl_IsChannelExisting(chanName)
*----------------------------------------------------------------------
*/
-CONST char *
-Tcl_ChannelName(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+const char *
+Tcl_ChannelName(
+ const Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->typeName;
}
@@ -9077,8 +9957,9 @@ Tcl_ChannelName(chanTypePtr)
*/
Tcl_ChannelTypeVersion
-Tcl_ChannelVersion(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelVersion(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
return TCL_CHANNEL_VERSION_2;
@@ -9086,11 +9967,14 @@ Tcl_ChannelVersion(chanTypePtr)
return TCL_CHANNEL_VERSION_3;
} else if (chanTypePtr->version == TCL_CHANNEL_VERSION_4) {
return TCL_CHANNEL_VERSION_4;
+ } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_5) {
+ return TCL_CHANNEL_VERSION_5;
} else {
/*
- * In <v2 channel versions, the version field is occupied
- * by the Tcl_DriverBlockModeProc
+ * In <v2 channel versions, the version field is occupied by the
+ * Tcl_DriverBlockModeProc
*/
+
return TCL_CHANNEL_VERSION_1;
}
}
@@ -9113,13 +9997,13 @@ Tcl_ChannelVersion(chanTypePtr)
*/
static int
-HaveVersion(chanTypePtr, minimumVersion)
- Tcl_ChannelType *chanTypePtr;
- Tcl_ChannelTypeVersion minimumVersion;
+HaveVersion(
+ const Tcl_ChannelType *chanTypePtr,
+ Tcl_ChannelTypeVersion minimumVersion)
{
Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr);
- return ((int)actualVersion) >= ((int)minimumVersion);
+ return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion));
}
/*
@@ -9138,8 +10022,9 @@ HaveVersion(chanTypePtr, minimumVersion)
*---------------------------------------------------------------------- */
Tcl_DriverBlockModeProc *
-Tcl_ChannelBlockModeProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelBlockModeProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->blockModeProc;
@@ -9147,6 +10032,7 @@ Tcl_ChannelBlockModeProc(chanTypePtr)
/*
* The v1 structure had the blockModeProc in a different place.
*/
+
return (Tcl_DriverBlockModeProc *) (chanTypePtr->version);
}
}
@@ -9168,8 +10054,9 @@ Tcl_ChannelBlockModeProc(chanTypePtr)
*/
Tcl_DriverCloseProc *
-Tcl_ChannelCloseProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelCloseProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->closeProc;
}
@@ -9191,8 +10078,9 @@ Tcl_ChannelCloseProc(chanTypePtr)
*/
Tcl_DriverClose2Proc *
-Tcl_ChannelClose2Proc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelClose2Proc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->close2Proc;
}
@@ -9214,8 +10102,9 @@ Tcl_ChannelClose2Proc(chanTypePtr)
*/
Tcl_DriverInputProc *
-Tcl_ChannelInputProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelInputProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->inputProc;
}
@@ -9237,8 +10126,9 @@ Tcl_ChannelInputProc(chanTypePtr)
*/
Tcl_DriverOutputProc *
-Tcl_ChannelOutputProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelOutputProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->outputProc;
}
@@ -9260,8 +10150,9 @@ Tcl_ChannelOutputProc(chanTypePtr)
*/
Tcl_DriverSeekProc *
-Tcl_ChannelSeekProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelSeekProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->seekProc;
}
@@ -9283,8 +10174,9 @@ Tcl_ChannelSeekProc(chanTypePtr)
*/
Tcl_DriverSetOptionProc *
-Tcl_ChannelSetOptionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelSetOptionProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->setOptionProc;
}
@@ -9306,8 +10198,9 @@ Tcl_ChannelSetOptionProc(chanTypePtr)
*/
Tcl_DriverGetOptionProc *
-Tcl_ChannelGetOptionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelGetOptionProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->getOptionProc;
}
@@ -9329,8 +10222,9 @@ Tcl_ChannelGetOptionProc(chanTypePtr)
*/
Tcl_DriverWatchProc *
-Tcl_ChannelWatchProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelWatchProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->watchProc;
}
@@ -9352,8 +10246,9 @@ Tcl_ChannelWatchProc(chanTypePtr)
*/
Tcl_DriverGetHandleProc *
-Tcl_ChannelGetHandleProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelGetHandleProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->getHandleProc;
}
@@ -9375,8 +10270,9 @@ Tcl_ChannelGetHandleProc(chanTypePtr)
*/
Tcl_DriverFlushProc *
-Tcl_ChannelFlushProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelFlushProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->flushProc;
@@ -9402,8 +10298,9 @@ Tcl_ChannelFlushProc(chanTypePtr)
*/
Tcl_DriverHandlerProc *
-Tcl_ChannelHandlerProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelHandlerProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->handlerProc;
@@ -9429,8 +10326,9 @@ Tcl_ChannelHandlerProc(chanTypePtr)
*/
Tcl_DriverWideSeekProc *
-Tcl_ChannelWideSeekProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelWideSeekProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) {
return chanTypePtr->wideSeekProc;
@@ -9444,7 +10342,8 @@ Tcl_ChannelWideSeekProc(chanTypePtr)
*
* Tcl_ChannelThreadActionProc --
*
- * 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.
@@ -9456,8 +10355,9 @@ Tcl_ChannelWideSeekProc(chanTypePtr)
*/
Tcl_DriverThreadActionProc *
-Tcl_ChannelThreadActionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelThreadActionProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
return chanTypePtr->threadActionProc;
@@ -9465,43 +10365,534 @@ Tcl_ChannelThreadActionProc(chanTypePtr)
return NULL;
}
}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetChannelErrorInterp --
+ *
+ * TIP #219, Tcl Channel Reflection API.
+ * Store an error message for the I/O system.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Discards a previously stored message.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetChannelErrorInterp(
+ Tcl_Interp *interp, /* Interp to store the data into. */
+ Tcl_Obj *msg) /* Error message to store. */
+{
+ Interp *iPtr = (Interp *) interp;
+
+ if (iPtr->chanMsg != NULL) {
+ TclDecrRefCount(iPtr->chanMsg);
+ iPtr->chanMsg = NULL;
+ }
+
+ if (msg != NULL) {
+ iPtr->chanMsg = FixLevelCode(msg);
+ Tcl_IncrRefCount(iPtr->chanMsg);
+ }
+ return;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetChannelError --
+ *
+ * TIP #219, Tcl Channel Reflection API.
+ * Store an error message for the I/O system.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Discards a previously stored message.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetChannelError(
+ Tcl_Channel chan, /* Channel to store the data into. */
+ Tcl_Obj *msg) /* Error message to store. */
+{
+ ChannelState *statePtr = ((Channel *) chan)->state;
+
+ if (statePtr->chanMsg != NULL) {
+ TclDecrRefCount(statePtr->chanMsg);
+ statePtr->chanMsg = NULL;
+ }
+
+ if (msg != NULL) {
+ statePtr->chanMsg = FixLevelCode(msg);
+ Tcl_IncrRefCount(statePtr->chanMsg);
+ }
+ return;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FixLevelCode --
+ *
+ * TIP #219, Tcl Channel Reflection API.
+ * Scans an error message for bad -code / -level directives. Returns a
+ * modified copy with such directives corrected, and the input if it had
+ * no problems.
+ *
+ * Results:
+ * A Tcl_Obj*
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Tcl_Obj *
+FixLevelCode(
+ Tcl_Obj *msg)
+{
+ int explicitResult, numOptions, lc, lcn;
+ Tcl_Obj **lv, **lvn;
+ int res, i, j, val, lignore, cignore;
+ int newlevel = -1, newcode = -1;
+
+ /* ASSERT msg != NULL */
+
+ /*
+ * Process the caught message.
+ *
+ * Syntax = (option value)... ?message?
+ *
+ * Bad message syntax causes a panic, because the other side uses
+ * Tcl_GetReturnOptions and list construction functions to marshall the
+ * information. Hence an error means that we've got serious breakage.
+ */
+
+ res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv);
+ if (res != TCL_OK) {
+ Tcl_Panic("Tcl_SetChannelError(Interp): Bad syntax of message");
+ }
+
+ explicitResult = (1 == (lc % 2));
+ numOptions = lc - explicitResult;
+
+ /*
+ * No options, nothing to do.
+ */
+
+ if (numOptions == 0) {
+ return msg;
+ }
+
+ /*
+ * Check for -code x, x != 1|error, and -level x, x != 0
+ */
+
+ for (i = 0; i < numOptions; i += 2) {
+ if (0 == strcmp(TclGetString(lv[i]), "-code")) {
+ /*
+ * !"error", !integer, integer != 1 (numeric code for error)
+ */
+
+ res = TclGetIntFromObj(NULL, lv[i+1], &val);
+ if (((res == TCL_OK) && (val != 1)) || ((res != TCL_OK) &&
+ (0 != strcmp(TclGetString(lv[i+1]), "error")))) {
+ newcode = 1;
+ }
+ } else if (0 == strcmp(TclGetString(lv[i]), "-level")) {
+ /*
+ * !integer, integer != 0
+ */
+
+ res = TclGetIntFromObj(NULL, lv [i+1], &val);
+ if ((res != TCL_OK) || (val != 0)) {
+ newlevel = 0;
+ }
+ }
+ }
+
+ /*
+ * -code, -level are either not present or ok. Nothing to do.
+ */
+
+ if ((newlevel < 0) && (newcode < 0)) {
+ return msg;
+ }
+
+ lcn = numOptions;
+ if (explicitResult) {
+ lcn ++;
+ }
+ if (newlevel >= 0) {
+ lcn += 2;
+ }
+ if (newcode >= 0) {
+ lcn += 2;
+ }
+
+ lvn = (Tcl_Obj **) ckalloc(lcn * sizeof(Tcl_Obj *));
+
+ /*
+ * New level/code information is spliced into the first occurence of
+ * -level, -code, further occurences are ignored. The options cannot be
+ * not present, we would not come here. Options which are ok are simply
+ * copied over.
+ */
+
+ lignore = cignore = 0;
+ for (i=0, j=0; i<numOptions; i+=2) {
+ if (0 == strcmp(TclGetString(lv[i]), "-level")) {
+ if (newlevel >= 0) {
+ lvn[j++] = lv[i];
+ lvn[j++] = Tcl_NewIntObj(newlevel);
+ newlevel = -1;
+ lignore = 1;
+ continue;
+ } else if (lignore) {
+ continue;
+ }
+ } else if (0 == strcmp(TclGetString(lv[i]), "-code")) {
+ if (newcode >= 0) {
+ lvn[j++] = lv[i];
+ lvn[j++] = Tcl_NewIntObj(newcode);
+ newcode = -1;
+ cignore = 1;
+ continue;
+ } else if (cignore) {
+ continue;
+ }
+ }
+
+ /*
+ * Keep everything else, possibly copied down.
+ */
+
+ lvn[j++] = lv[i];
+ lvn[j++] = lv[i+1];
+ }
+ if (newlevel >= 0) {
+ Tcl_Panic("Defined newlevel not used in rewrite");
+ }
+ if (newcode >= 0) {
+ Tcl_Panic("Defined newcode not used in rewrite");
+ }
+
+ if (explicitResult) {
+ lvn[j++] = lv[i];
+ }
+
+ msg = Tcl_NewListObj(j, lvn);
+
+ ckfree((char *) lvn);
+ return msg;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelErrorInterp --
+ *
+ * TIP #219, Tcl Channel Reflection API.
+ * Return the message stored by the channel driver.
+ *
+ * Results:
+ * Tcl error message object.
+ *
+ * Side effects:
+ * Resets the stored data to NULL.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_GetChannelErrorInterp(
+ Tcl_Interp *interp, /* Interp to query. */
+ Tcl_Obj **msg) /* Place for error message. */
+{
+ Interp *iPtr = (Interp *) interp;
+
+ *msg = iPtr->chanMsg;
+ iPtr->chanMsg = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelError --
+ *
+ * TIP #219, Tcl Channel Reflection API.
+ * Return the message stored by the channel driver.
+ *
+ * Results:
+ * Tcl error message object.
+ *
+ * Side effects:
+ * Resets the stored data to NULL.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_GetChannelError(
+ Tcl_Channel chan, /* Channel to query. */
+ Tcl_Obj **msg) /* Place for error message. */
+{
+ ChannelState *statePtr = ((Channel *) chan)->state;
+
+ *msg = statePtr->chanMsg;
+ statePtr->chanMsg = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelTruncateProc --
+ *
+ * TIP #208 (subsection relating to truncation, based on TIP #206).
+ * Return the Tcl_DriverTruncateProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverTruncateProc *
+Tcl_ChannelTruncateProc(
+ const Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
+{
+ if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) {
+ return chanTypePtr->truncateProc;
+ } else {
+ return NULL;
+ }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DupChannelIntRep --
+ *
+ * Initialize the internal representation of a new Tcl_Obj to a copy of
+ * the internal representation of an existing string object.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * copyPtr's internal rep is set to a copy of srcPtr's internal
+ * representation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DupChannelIntRep(
+ register Tcl_Obj *srcPtr, /* Object with internal rep to copy. Must have
+ * an internal rep of type "Channel". */
+ register Tcl_Obj *copyPtr) /* Object with internal rep to set. Must not
+ * currently have an internal rep.*/
+{
+ ChannelState *statePtr = GET_CHANNELSTATE(srcPtr);
+ Interp *interpPtr = GET_CHANNELINTERP(srcPtr);
+
+ SET_CHANNELSTATE(copyPtr, statePtr);
+ SET_CHANNELINTERP(copyPtr, interpPtr);
+ Tcl_Preserve((ClientData) statePtr);
+ copyPtr->typePtr = &tclChannelType;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * SetChannelFromAny --
+ *
+ * Create an internal representation of type "Channel" for an object.
+ *
+ * Results:
+ * This operation always succeeds and returns TCL_OK.
+ *
+ * Side effects:
+ * Any old internal reputation for objPtr is freed and the internal
+ * representation is set to "Channel".
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+SetChannelFromAny(
+ Tcl_Interp *interp, /* Used for error reporting if not NULL. */
+ register Tcl_Obj *objPtr) /* The object to convert. */
+{
+ ChannelState *statePtr;
+ Interp *interpPtr;
+
+ if (objPtr->typePtr == &tclChannelType) {
+ /*
+ * The channel is valid until any call to DetachChannel occurs.
+ * Ensure consistency checks are done.
+ */
+ statePtr = GET_CHANNELSTATE(objPtr);
+ interpPtr = GET_CHANNELINTERP(objPtr);
+ if (statePtr->flags & (CHANNEL_TAINTED|CHANNEL_CLOSED)) {
+ ResetFlag(statePtr, CHANNEL_TAINTED);
+ Tcl_Release((ClientData) statePtr);
+ UpdateStringOfChannel(objPtr);
+ objPtr->typePtr = NULL;
+ } else if (interpPtr != (Interp*) interp) {
+ Tcl_Release((ClientData) statePtr);
+ UpdateStringOfChannel(objPtr);
+ objPtr->typePtr = NULL;
+ }
+ }
+ if (objPtr->typePtr != &tclChannelType) {
+ Tcl_Channel chan;
+
+ /*
+ * We need a valid string with which to check for a valid channel, but
+ * make sure not to free internal rep until validated. [Bug 1847044]
+ */
+ if ((objPtr->typePtr != NULL) && (objPtr->bytes == NULL)) {
+ objPtr->typePtr->updateStringProc(objPtr);
+ }
+
+ chan = Tcl_GetChannel(interp, objPtr->bytes, NULL);
+ if (chan == NULL) {
+ return TCL_ERROR;
+ }
+
+ TclFreeIntRep(objPtr);
+ statePtr = ((Channel *)chan)->state;
+ Tcl_Preserve((ClientData) statePtr);
+ SET_CHANNELSTATE(objPtr, statePtr);
+ SET_CHANNELINTERP(objPtr, interp);
+ objPtr->typePtr = &tclChannelType;
+ }
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * UpdateStringOfChannel --
+ *
+ * Update the string representation for an object whose internal
+ * representation is "Channel".
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * The object's string may be set by converting its Unicode represention
+ * to UTF format.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+UpdateStringOfChannel(
+ Tcl_Obj *objPtr) /* Object with string rep to update. */
+{
+ if (objPtr->bytes == NULL) {
+ ChannelState *statePtr = GET_CHANNELSTATE(objPtr);
+ const char *name = statePtr->channelName;
+ if (name) {
+ size_t len = strlen(name);
+ objPtr->bytes = (char *) ckalloc(len + 1);
+ objPtr->length = len;
+ memcpy(objPtr->bytes, name, len);
+ } else {
+ objPtr->bytes = tclEmptyStringRep;
+ objPtr->length = 0;
+ }
+ }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FreeChannelIntRep --
+ *
+ * Release statePtr storage.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * May cause state to be freed.
+ *
+ *----------------------------------------------------------------------
+ */
+static void
+FreeChannelIntRep(
+ Tcl_Obj *objPtr) /* Object with internal rep to free. */
+{
+ Tcl_Release((ClientData) GET_CHANNELSTATE(objPtr));
+}
+
#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 buf [20];
- int i = 0;
-
- if (flags & TCL_READABLE) {buf[i] = 'r';} else {buf [i]='_';}; i++;
- if (flags & TCL_WRITABLE) {buf[i] = 'w';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_NONBLOCKING) {buf[i] = 'n';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_LINEBUFFERED) {buf[i] = 'l';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_UNBUFFERED) {buf[i] = 'u';} else {buf [i]='_';}; i++;
- if (flags & BUFFER_READY) {buf[i] = 'R';} else {buf [i]='_';}; i++;
- if (flags & BG_FLUSH_SCHEDULED) {buf[i] = 'F';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_CLOSED) {buf[i] = 'c';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_EOF) {buf[i] = 'E';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_STICKY_EOF) {buf[i] = 'S';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_BLOCKED) {buf[i] = 'B';} else {buf [i]='_';}; i++;
- if (flags & INPUT_SAW_CR) {buf[i] = '/';} else {buf [i]='_';}; i++;
- if (flags & INPUT_NEED_NL) {buf[i] = '*';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_DEAD) {buf[i] = 'D';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_RAW_MODE) {buf[i] = 'R';} else {buf [i]='_';}; i++;
+DumpFlags(
+ char *str,
+ int flags)
+{
+ char buf[20];
+ int i = 0;
+
+#define ChanFlag(chr,bit) (buf[i++] = ((flags & (bit)) ? (chr) : '_'))
+
+ ChanFlag('r', TCL_READABLE);
+ ChanFlag('w', TCL_WRITABLE);
+ ChanFlag('n', CHANNEL_NONBLOCKING);
+ ChanFlag('l', CHANNEL_LINEBUFFERED);
+ ChanFlag('u', CHANNEL_UNBUFFERED);
+ ChanFlag('R', BUFFER_READY);
+ ChanFlag('F', BG_FLUSH_SCHEDULED);
+ ChanFlag('c', CHANNEL_CLOSED);
+ ChanFlag('E', CHANNEL_EOF);
+ ChanFlag('S', CHANNEL_STICKY_EOF);
+ ChanFlag('B', CHANNEL_BLOCKED);
+ ChanFlag('/', INPUT_SAW_CR);
+ ChanFlag('*', INPUT_NEED_NL);
+ ChanFlag('D', CHANNEL_DEAD);
+ ChanFlag('R', CHANNEL_RAW_MODE);
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
- if (flags & CHANNEL_TIMER_FEV) {buf[i] = 'T';} else {buf [i]='_';}; i++;
- if (flags & CHANNEL_HAS_MORE_DATA) {buf[i] = 'H';} else {buf [i]='_';}; i++;
+ 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]='_';}; i++;
- buf [i] ='\0';
+ ChanFlag('x', CHANNEL_INCLOSE);
+
+ buf[i] ='\0';
- fprintf (stderr,"%s: %s\n", str, buf); fflush(stderr);
- return 0;
+ fprintf(stderr, "%s: %s\n", str, buf);
+ return 0;
}
#endif
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */