summaryrefslogtreecommitdiffstats
path: root/generic/tclIO.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclIO.c')
-rw-r--r--generic/tclIO.c4100
1 files changed, 2489 insertions, 1611 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 30161dc..5e12182 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -4,19 +4,21 @@
* This file provides the generic portions (those that are the same on
* all platforms and for all channel types) of Tcl's IO facilities.
*
+ * Copyright (c) 1998-2000 Ajuba Solutions
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
- * Copyright (c) 1998-2000 Scriptics Corporation
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclIO.c,v 1.23 2000/05/19 21:30:15 hobbs Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.24 2000/09/28 06:38:20 hobbs Exp $
*/
#include "tclInt.h"
#include "tclPort.h"
#include "tclIO.h"
+#include <assert.h>
+
/*
* All static variables used in this file are collected into a single
* instance of the following structure. For multi-threaded implementations,
@@ -35,9 +37,10 @@ typedef struct ThreadSpecificData {
NextChannelHandler *nestedHandlerPtr;
/*
- * List of all channels currently open.
+ * List of all channels currently open, indexed by ChannelState,
+ * as only one ChannelState exists per set of stacked channels.
*/
- Channel *firstChanPtr;
+ ChannelState *firstCSPtr;
#ifdef oldcode
/*
* Has a channel exit handler been created yet?
@@ -64,77 +67,83 @@ typedef struct ThreadSpecificData {
static Tcl_ThreadDataKey dataKey;
-
/*
* Static functions in this file:
*/
static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length));
static void ChannelTimerProc _ANSI_ARGS_((
- ClientData clientData));
-static int CheckChannelErrors _ANSI_ARGS_((Channel *chanPtr,
- int direction));
+ ClientData clientData));
+static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr,
+ int direction));
static int CheckFlush _ANSI_ARGS_((Channel *chanPtr,
- ChannelBuffer *bufPtr, int newlineFlag));
+ ChannelBuffer *bufPtr, int newlineFlag));
static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chan));
+ ChannelState *statePtr));
static void CheckForStdChannelsBeingClosed _ANSI_ARGS_((
- Tcl_Channel chan));
+ Tcl_Channel chan));
static void CleanupChannelHandlers _ANSI_ARGS_((
- Tcl_Interp *interp, Channel *chanPtr));
+ Tcl_Interp *interp, Channel *chanPtr));
static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int errorCode));
+ Channel *chanPtr, int errorCode));
static void CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr,
- Tcl_Encoding encoding));
+ Tcl_Encoding encoding));
static int CopyAndTranslateBuffer _ANSI_ARGS_((
- Channel *chanPtr, char *result, int space));
+ ChannelState *statePtr, char *result,
+ int space));
+static int CopyBuffer _ANSI_ARGS_((
+ Channel *chanPtr, char *result,
+ int space));
static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
static void CopyEventProc _ANSI_ARGS_((ClientData clientData,
- int mask));
+ int mask));
static void CreateScriptRecord _ANSI_ARGS_((
- Tcl_Interp *interp, Channel *chanPtr,
- int mask, Tcl_Obj *scriptPtr));
+ Tcl_Interp *interp, Channel *chanPtr,
+ int mask, Tcl_Obj *scriptPtr));
static void DeleteChannelTable _ANSI_ARGS_((
- ClientData clientData, Tcl_Interp *interp));
+ ClientData clientData, Tcl_Interp *interp));
static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mask));
-static void DiscardInputQueued _ANSI_ARGS_((
- Channel *chanPtr, int discardSavedBuffers));
+ Channel *chanPtr, int mask));
+static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr,
+ int discardSavedBuffers));
static void DiscardOutputQueued _ANSI_ARGS_((
- Channel *chanPtr));
+ ChannelState *chanPtr));
static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
- int slen));
+ int slen));
static int DoWrite _ANSI_ARGS_((Channel *chanPtr, char *src,
- int srcLen));
+ int srcLen));
static int FilterInputBytes _ANSI_ARGS_((Channel *chanPtr,
- GetsState *statePtr));
+ GetsState *statePtr));
static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int calledFromAsyncFlush));
+ Channel *chanPtr, int calledFromAsyncFlush));
static Tcl_HashTable * GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
static int GetInput _ANSI_ARGS_((Channel *chanPtr));
static void PeekAhead _ANSI_ARGS_((Channel *chanPtr,
- char **dstEndPtr, GetsState *gsPtr));
-static int ReadBytes _ANSI_ARGS_((Channel *chanPtr,
- Tcl_Obj *objPtr, int charsLeft, int *offsetPtr));
-static int ReadChars _ANSI_ARGS_((Channel *chanPtr,
- Tcl_Obj *objPtr, int charsLeft, int *offsetPtr,
- int *factorPtr));
-static void RecycleBuffer _ANSI_ARGS_((Channel *chanPtr,
- ChannelBuffer *bufPtr, int mustDiscard));
+ char **dstEndPtr, GetsState *gsPtr));
+static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr,
+ Tcl_Obj *objPtr, int charsLeft,
+ int *offsetPtr));
+static int ReadChars _ANSI_ARGS_((ChannelState *statePtr,
+ Tcl_Obj *objPtr, int charsLeft, int *offsetPtr,
+ int *factorPtr));
+static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr,
+ ChannelBuffer *bufPtr, int mustDiscard));
+static int StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr,
+ int mode));
static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mode));
+ Channel *chanPtr, int mode));
static void StopCopy _ANSI_ARGS_((CopyState *csPtr));
-static int TranslateInputEOL _ANSI_ARGS_((Channel *chanPtr,
- char *dst, CONST char *src, int *dstLenPtr,
- int *srcLenPtr));
-static int TranslateOutputEOL _ANSI_ARGS_((Channel *chanPtr,
- char *dst, CONST char *src, int *dstLenPtr,
- int *srcLenPtr));
+static int TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr,
+ char *dst, CONST char *src, int *dstLenPtr,
+ int *srcLenPtr));
+static int TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr,
+ char *dst, CONST char *src, int *dstLenPtr,
+ int *srcLenPtr));
static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
static int WriteBytes _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
+ CONST char *src, int srcLen));
static int WriteChars _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
+ CONST char *src, int srcLen));
/*
@@ -188,12 +197,13 @@ TclFinalizeIOSubsystem()
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
Channel *chanPtr; /* Iterates over open channels. */
- Channel *nextChanPtr; /* Iterates over open channels. */
-
+ ChannelState *nextCSPtr; /* Iterates over open channels. */
+ ChannelState *statePtr; /* state of channel stack */
- for (chanPtr = tsdPtr->firstChanPtr; chanPtr != (Channel *) NULL;
- chanPtr = nextChanPtr) {
- nextChanPtr = chanPtr->nextChanPtr;
+ for (statePtr = tsdPtr->firstCSPtr; statePtr != (ChannelState *) NULL;
+ statePtr = nextCSPtr) {
+ chanPtr = statePtr->topChanPtr;
+ nextCSPtr = statePtr->nextCSPtr;
/*
* Set the channel back into blocking mode to ensure that we wait
@@ -212,10 +222,10 @@ TclFinalizeIOSubsystem()
* up to keep the channel from being closed.
*/
- chanPtr->refCount--;
+ statePtr->refCount--;
}
- if (chanPtr->refCount <= 0) {
+ if (statePtr->refCount <= 0) {
/*
* Close it only if the refcount indicates that the channel is not
@@ -254,7 +264,7 @@ TclFinalizeIOSubsystem()
*/
chanPtr->instanceData = (ClientData) NULL;
- chanPtr->flags |= CHANNEL_DEAD;
+ statePtr->flags |= CHANNEL_DEAD;
}
}
}
@@ -403,17 +413,17 @@ Tcl_CreateCloseHandler(chan, proc, clientData)
ClientData clientData; /* Arbitrary data to pass to the
* close callback. */
{
- Channel *chanPtr;
+ ChannelState *statePtr;
CloseCallback *cbPtr;
- chanPtr = (Channel *) chan;
+ statePtr = ((Channel *) chan)->state;
cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
cbPtr->proc = proc;
cbPtr->clientData = clientData;
- cbPtr->nextPtr = chanPtr->closeCbPtr;
- chanPtr->closeCbPtr = cbPtr;
+ cbPtr->nextPtr = statePtr->closeCbPtr;
+ statePtr->closeCbPtr = cbPtr;
}
/*
@@ -444,16 +454,16 @@ Tcl_DeleteCloseHandler(chan, proc, clientData)
ClientData clientData; /* The callback data for the callback
* to remove. */
{
- Channel *chanPtr;
+ ChannelState *statePtr;
CloseCallback *cbPtr, *cbPrevPtr;
- chanPtr = (Channel *) chan;
- for (cbPtr = chanPtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
- cbPtr != (CloseCallback *) NULL;
- cbPtr = cbPtr->nextPtr) {
+ statePtr = ((Channel *) chan)->state;
+ for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
+ cbPtr != (CloseCallback *) NULL;
+ cbPtr = cbPtr->nextPtr) {
if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
if (cbPrevPtr == (CloseCallback *) NULL) {
- chanPtr->closeCbPtr = cbPtr->nextPtr;
+ statePtr->closeCbPtr = cbPtr->nextPtr;
}
ckfree((char *) cbPtr);
break;
@@ -553,12 +563,13 @@ DeleteChannelTable(clientData, interp)
Tcl_HashTable *hTblPtr; /* The hash table. */
Tcl_HashSearch hSearch; /* Search variable. */
Tcl_HashEntry *hPtr; /* Search variable. */
- Channel *chanPtr; /* Channel being deleted. */
+ Channel *chanPtr; /* Channel being deleted. */
+ ChannelState *statePtr; /* State of Channel being deleted. */
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
/* Variables to loop over all channel events
* registered, to delete the ones that refer
* to the interpreter being deleted. */
-
+
/*
* Delete all the registered channels - this will close channels whose
* refcount reaches zero.
@@ -566,23 +577,24 @@ DeleteChannelTable(clientData, interp)
hTblPtr = (Tcl_HashTable *) clientData;
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
- hPtr != (Tcl_HashEntry *) NULL;
- hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
+ hPtr != (Tcl_HashEntry *) NULL;
+ hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
+ statePtr = chanPtr->state;
/*
* Remove any fileevents registered in this interpreter.
*/
- for (sPtr = chanPtr->scriptRecordPtr,
+ for (sPtr = statePtr->scriptRecordPtr,
prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
+ sPtr != (EventScriptRecord *) NULL;
+ sPtr = nextPtr) {
nextPtr = sPtr->nextPtr;
if (sPtr->interp == interp) {
if (prevPtr == (EventScriptRecord *) NULL) {
- chanPtr->scriptRecordPtr = nextPtr;
+ statePtr->scriptRecordPtr = nextPtr;
} else {
prevPtr->nextPtr = nextPtr;
}
@@ -605,9 +617,9 @@ DeleteChannelTable(clientData, interp)
*/
Tcl_DeleteHashEntry(hPtr);
- chanPtr->refCount--;
- if (chanPtr->refCount <= 0) {
- if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+ statePtr->refCount--;
+ if (statePtr->refCount <= 0) {
+ if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
(void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
}
}
@@ -642,24 +654,26 @@ static void
CheckForStdChannelsBeingClosed(chan)
Tcl_Channel chan;
{
- Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = ((Channel *) chan)->state;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) {
- if (chanPtr->refCount < 2) {
- chanPtr->refCount = 0;
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
tsdPtr->stdinChannel = NULL;
return;
}
- } else if ((chan == tsdPtr->stdoutChannel) && (tsdPtr->stdoutInitialized)) {
- if (chanPtr->refCount < 2) {
- chanPtr->refCount = 0;
+ } else if ((chan == tsdPtr->stdoutChannel)
+ && (tsdPtr->stdoutInitialized)) {
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
tsdPtr->stdoutChannel = NULL;
return;
}
- } else if ((chan == tsdPtr->stderrChannel) && (tsdPtr->stderrInitialized)) {
- if (chanPtr->refCount < 2) {
- chanPtr->refCount = 0;
+ } else if ((chan == tsdPtr->stderrChannel)
+ && (tsdPtr->stderrInitialized)) {
+ if (statePtr->refCount < 2) {
+ statePtr->refCount = 0;
tsdPtr->stderrChannel = NULL;
return;
}
@@ -694,38 +708,32 @@ Tcl_RegisterChannel(interp, chan)
Tcl_HashEntry *hPtr; /* Search variable. */
int new; /* Is the hash entry new or does it exist? */
Channel *chanPtr; /* The actual channel. */
+ ChannelState *statePtr; /* State of the actual channel. */
- chanPtr = (Channel *) chan;
+ /*
+ * Always (un)register bottom-most channel in the stack. This makes
+ * management of the channel list easier because no manipulation is
+ * necessary during (un)stack operation.
+ */
+ chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ statePtr = chanPtr->state;
- if (chanPtr->channelName == (char *) NULL) {
+ if (statePtr->channelName == (char *) NULL) {
panic("Tcl_RegisterChannel: channel without name");
}
if (interp != (Tcl_Interp *) NULL) {
hTblPtr = GetChannelTable(interp);
- hPtr = Tcl_CreateHashEntry(hTblPtr, chanPtr->channelName, &new);
+ hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new);
if (new == 0) {
if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
return;
}
- /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998
- * "Trf-Patch for filtering channels"
- *
- * This is the change to 'Tcl_RegisterChannel'.
- *
- * Explanation:
- * The moment a channel is stacked upon another he
- * takes the identity of the channel he supercedes,
- * i.e. he gets the *same* name. Because of this we
- * cannot check for duplicate names anymore, they
- * have to be allowed now.
- */
-
- /* panic("Tcl_RegisterChannel: duplicate channel names"); */
+ panic("Tcl_RegisterChannel: duplicate channel names");
}
Tcl_SetHashValue(hPtr, (ClientData) chanPtr);
}
- chanPtr->refCount++;
+ statePtr->refCount++;
}
/*
@@ -754,15 +762,22 @@ Tcl_UnregisterChannel(interp, chan)
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of the real channel. */
+
+ /*
+ * Always (un)register bottom-most channel in the stack. This makes
+ * management of the channel list easier because no manipulation is
+ * necessary during (un)stack operation.
+ */
+ chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ statePtr = chanPtr->state;
- chanPtr = (Channel *) chan;
-
if (interp != (Tcl_Interp *) NULL) {
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
if (hTblPtr == (Tcl_HashTable *) NULL) {
return TCL_OK;
}
- hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
+ hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
if (hPtr == (Tcl_HashEntry *) NULL) {
return TCL_OK;
}
@@ -782,7 +797,7 @@ Tcl_UnregisterChannel(interp, chan)
CleanupChannelHandlers(interp, chanPtr);
}
- chanPtr->refCount--;
+ statePtr->refCount--;
/*
* Perform special handling for standard channels being closed. If the
@@ -798,20 +813,20 @@ Tcl_UnregisterChannel(interp, chan)
* If the refCount reached zero, close the actual channel.
*/
- if (chanPtr->refCount <= 0) {
+ if (statePtr->refCount <= 0) {
/*
* Ensure that if there is another buffer, it gets flushed
* whether or not we are doing a background flush.
*/
- if ((chanPtr->curOutPtr != NULL) &&
- (chanPtr->curOutPtr->nextAdded >
- chanPtr->curOutPtr->nextRemoved)) {
- chanPtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != NULL) &&
+ (statePtr->curOutPtr->nextAdded >
+ statePtr->curOutPtr->nextRemoved)) {
+ statePtr->flags |= BUFFER_READY;
}
- chanPtr->flags |= CHANNEL_CLOSED;
- if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+ statePtr->flags |= CHANNEL_CLOSED;
+ if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
if (Tcl_Close(interp, chan) != TCL_OK) {
return TCL_ERROR;
}
@@ -821,134 +836,6 @@ Tcl_UnregisterChannel(interp, chan)
}
/*
- *----------------------------------------------------------------------
- *
- * Tcl_IsChannelRegistered --
- *
- * Checks whether the channel is associated with the interp.
- *
- * Results:
- * 0 if the channel is not registered in the interpreter, 1 else.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_IsChannelRegistered (interp, chan)
- Tcl_Interp* interp; /* The interp to query of the channel */
- Tcl_Channel chan; /* The channel to check */
-{
- Tcl_HashTable *hTblPtr; /* Hash table of channels. */
- Tcl_HashEntry *hPtr; /* Search variable. */
- Channel *chanPtr; /* The real IO channel. */
-
- chanPtr = (Channel *) chan;
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
-
- if (hTblPtr == (Tcl_HashTable *) NULL) {
- return 0;
- }
-
- hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
-
- if (hPtr == (Tcl_HashEntry *) NULL) {
- return 0;
- }
- if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
- return 0;
- }
-
- return 1;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_IsChannelShared --
- *
- * Checks whether the channel is shared by multiple interpreters.
- *
- * Results:
- * A boolean value (0 = Not shared, 1 = Shared).
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_IsChannelShared (chan)
- Tcl_Channel chan; /* The channel to query */
-{
- Channel *chanPtr; /* The real IO channel. */
-
- chanPtr = (Channel *) chan;
-
- return (chanPtr->refCount > 1) ? 1 : 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_IsChannelExisting --
- *
- * Checks whether a channel of the given name exists in the
- * (thread)-global list of all channels.
- *
- * Results:
- * A boolean value (0 = Does not exist, 1 = Does exist).
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_IsChannelExisting (chanName)
- CONST char* chanName; /* The name of the channel to look for. */
-{
- Channel *chanPtr;
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- char *name;
- int cLen, nLen, match;
-
- cLen = strlen (chanName);
-
- for (chanPtr = tsdPtr->firstChanPtr;
- chanPtr != NULL;
- chanPtr = chanPtr->nextChanPtr) {
- if (chanPtr == (Channel *) tsdPtr->stdinChannel) {
- name = "stdin";
- } else if (chanPtr == (Channel *) tsdPtr->stdoutChannel) {
- name = "stdout";
- } else if (chanPtr == (Channel *) tsdPtr->stderrChannel) {
- name = "stderr";
- } else {
- name = chanPtr->channelName;
- }
-
- nLen = strlen (name);
-
- if (nLen != cLen) {
- continue;
- }
-
- match = memcmp(name, chanName, (unsigned) cLen);
-
- if (match == 0) {
- return 1;
- }
- }
-
- return 0;
-}
-
-/*
*---------------------------------------------------------------------------
*
* Tcl_GetChannel --
@@ -995,17 +882,17 @@ Tcl_GetChannel(interp, chanName, modePtr)
if ((chanName[0] == 's') && (chanName[1] == 't')) {
chanPtr = NULL;
if (strcmp(chanName, "stdin") == 0) {
- chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDIN);
+ chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDIN);
} else if (strcmp(chanName, "stdout") == 0) {
- chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDOUT);
+ chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDOUT);
} else if (strcmp(chanName, "stderr") == 0) {
- chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDERR);
+ chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDERR);
}
if (chanPtr != NULL) {
- name = chanPtr->channelName;
+ name = chanPtr->state->channelName;
}
}
-
+
hTblPtr = GetChannelTable(interp);
hPtr = Tcl_FindHashEntry(hTblPtr, name);
if (hPtr == (Tcl_HashEntry *) NULL) {
@@ -1014,9 +901,16 @@ Tcl_GetChannel(interp, chanName, modePtr)
return NULL;
}
+ /*
+ * Always return bottom-most channel in the stack. This one lives
+ * the longest - other channels may go away unnoticed.
+ * The other APIs compensate where necessary to retrieve the
+ * topmost channel again.
+ */
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
+ chanPtr = chanPtr->state->bottomChanPtr;
if (modePtr != NULL) {
- *modePtr = (chanPtr->flags & (TCL_READABLE|TCL_WRITABLE));
+ *modePtr = (chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE));
}
return (Tcl_Channel) chanPtr;
@@ -1049,33 +943,61 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
* if the channel is readable, writable. */
{
Channel *chanPtr; /* The channel structure newly created. */
+ ChannelState *statePtr; /* The stack-level independent state info
+ * for the channel. */
CONST char *name;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
-
+ /*
+ * With the change of the Tcl_ChannelType structure to use a version in
+ * 8.3.2+, we have to make sure that our assumption that the structure
+ * remains a binary compatible size is true.
+ *
+ * If this assertion fails on some system, then it can be removed
+ * only if the user recompiles code with older channel drivers in
+ * the new system as well.
+ */
+
+ assert(sizeof(Tcl_ChannelTypeVersion) == sizeof(Tcl_DriverBlockModeProc*));
+
+ /*
+ * JH: We could subsequently memset these to 0 to avoid the
+ * numerous assignments to 0/NULL below.
+ */
+ chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
+ statePtr = (ChannelState *) ckalloc((unsigned) sizeof(ChannelState));
+ chanPtr->state = statePtr;
+
+ chanPtr->instanceData = instanceData;
+ chanPtr->typePtr = typePtr;
+
+ /*
+ * Set all the bits that are part of the stack-independent state
+ * information for the channel.
+ */
+
if (chanName != (char *) NULL) {
- chanPtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
- strcpy(chanPtr->channelName, chanName);
+ statePtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
+ strcpy(statePtr->channelName, chanName);
} else {
panic("Tcl_CreateChannel: NULL channel name");
}
- chanPtr->flags = mask;
+ statePtr->flags = mask;
/*
* Set the channel to system default encoding.
*/
- chanPtr->encoding = NULL;
+ statePtr->encoding = NULL;
name = Tcl_GetEncodingName(NULL);
if (strcmp(name, "binary") != 0) {
- chanPtr->encoding = Tcl_GetEncoding(NULL, name);
+ statePtr->encoding = Tcl_GetEncoding(NULL, name);
}
- chanPtr->inputEncodingState = NULL;
- chanPtr->inputEncodingFlags = TCL_ENCODING_START;
- chanPtr->outputEncodingState = NULL;
- chanPtr->outputEncodingFlags = TCL_ENCODING_START;
+ statePtr->inputEncodingState = NULL;
+ statePtr->inputEncodingFlags = TCL_ENCODING_START;
+ statePtr->outputEncodingState = NULL;
+ statePtr->outputEncodingFlags = TCL_ENCODING_START;
/*
* Set the channel up initially in AUTO input translation mode to
@@ -1085,58 +1007,70 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
* indicator (e.g. ^Z) and does not append an EOF indicator to files.
*/
- chanPtr->inputTranslation = TCL_TRANSLATE_AUTO;
- chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
- chanPtr->inEofChar = 0;
- chanPtr->outEofChar = 0;
-
- chanPtr->unreportedError = 0;
- chanPtr->instanceData = instanceData;
- chanPtr->typePtr = typePtr;
- chanPtr->refCount = 0;
- chanPtr->closeCbPtr = (CloseCallback *) NULL;
- chanPtr->curOutPtr = (ChannelBuffer *) NULL;
- chanPtr->outQueueHead = (ChannelBuffer *) NULL;
- chanPtr->outQueueTail = (ChannelBuffer *) NULL;
- chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
- chanPtr->chPtr = (ChannelHandler *) NULL;
- chanPtr->interestMask = 0;
- chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
- chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
- chanPtr->timer = NULL;
- chanPtr->csPtr = NULL;
- chanPtr->supercedes = (Channel*) NULL;
- chanPtr->nextChanPtr = (Channel*) NULL;
-
- chanPtr->outputStage = NULL;
- if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
- chanPtr->outputStage = (char *)
- ckalloc((unsigned) (chanPtr->bufSize + 2));
+ statePtr->inputTranslation = TCL_TRANSLATE_AUTO;
+ statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+ statePtr->inEofChar = 0;
+ statePtr->outEofChar = 0;
+
+ statePtr->unreportedError = 0;
+ statePtr->refCount = 0;
+ statePtr->closeCbPtr = (CloseCallback *) NULL;
+ statePtr->curOutPtr = (ChannelBuffer *) NULL;
+ statePtr->outQueueHead = (ChannelBuffer *) NULL;
+ statePtr->outQueueTail = (ChannelBuffer *) NULL;
+ statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
+ statePtr->inQueueHead = (ChannelBuffer *) NULL;
+ statePtr->inQueueTail = (ChannelBuffer *) NULL;
+ statePtr->chPtr = (ChannelHandler *) NULL;
+ statePtr->interestMask = 0;
+ statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
+ statePtr->timer = NULL;
+ statePtr->csPtr = NULL;
+
+ statePtr->outputStage = NULL;
+ if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+ statePtr->outputStage = (char *)
+ ckalloc((unsigned) (statePtr->bufSize + 2));
}
/*
+ * As we are creating the channel, it is obviously the top for now
+ */
+ statePtr->topChanPtr = chanPtr;
+ statePtr->bottomChanPtr = chanPtr;
+ chanPtr->downChanPtr = (Channel *) NULL;
+ chanPtr->upChanPtr = (Channel *) NULL;
+ chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+ chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+
+ /*
* Link the channel into the list of all channels; create an on-exit
* handler if there is not one already, to close off all the channels
* in the list on exit.
+ *
+ * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check.
*/
- Tcl_SpliceChannel ((Tcl_Channel) chanPtr);
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
/*
* Install this channel in the first empty standard channel slot, if
* the channel was previously closed explicitly.
*/
- if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) {
- Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDIN);
+ if ((tsdPtr->stdinChannel == NULL) &&
+ (tsdPtr->stdinInitialized == 1)) {
+ Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN);
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
- } else if ((tsdPtr->stdoutChannel == NULL) && (tsdPtr->stdoutInitialized == 1)) {
- Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDOUT);
+ } else if ((tsdPtr->stdoutChannel == NULL) &&
+ (tsdPtr->stdoutInitialized == 1)) {
+ Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT);
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
- } else if ((tsdPtr->stderrChannel == NULL) && (tsdPtr->stderrInitialized == 1)) {
- Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDERR);
+ } else if ((tsdPtr->stderrChannel == NULL) &&
+ (tsdPtr->stderrInitialized == 1)) {
+ Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR);
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
}
return (Tcl_Channel) chanPtr;
@@ -1173,53 +1107,36 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
Tcl_Channel
Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
- Tcl_Interp* interp; /* The interpreter we are working in */
+ Tcl_Interp *interp; /* The interpreter we are working in */
Tcl_ChannelType *typePtr; /* The channel type record for the new
* channel. */
- ClientData instanceData; /* Instance specific data for the new
+ ClientData instanceData; /* Instance specific data for the new
* channel. */
- int mask; /* TCL_READABLE & TCL_WRITABLE to indicate
+ int mask; /* TCL_READABLE & TCL_WRITABLE to indicate
* if the channel is readable, writable. */
- Tcl_Channel prevChan; /* The channel structure to replace */
+ Tcl_Channel prevChan; /* The channel structure to replace */
{
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- Channel *chanPtr, *pt;
- int interest = 0;
-
- /*
- * AK, 06/30/1999
- *
- * Tcl_StackChannel differs from Tcl_ReplaceChannel of the
- * original "Trf" patch. Instead of seeing the
- * newly created structure as the *new* channel to cover the specified
- * one use it to *save* the current state of the specified channel and
- * then reinitialize the current structure for the given transformation.
- *
- * Advantages:
- * - No splicing into the (thread-)global list of channels (or the per-
- * interp hash-tables).
- * - Users of the C-API still have valid channel references even after
- * the call to this procedure.
- *
- * Disadvantages:
- * - Untested code.
- */
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ Channel *chanPtr, *prevChanPtr;
+ ChannelState *statePtr;
/*
* Find the given channel in the list of all channels.
+ * If we don't find it, then it was never registered correctly.
+ *
+ * This operation should occur at the top of a channel stack.
*/
- pt = (Channel*) tsdPtr->firstChanPtr;
+ statePtr = (ChannelState *) tsdPtr->firstCSPtr;
+ prevChanPtr = ((Channel *) prevChan)->state->topChanPtr;
- while (pt != (Channel *) prevChan) {
- pt = pt->nextChanPtr;
+ while (statePtr->topChanPtr != prevChanPtr) {
+ statePtr = statePtr->nextCSPtr;
}
- /*
- * 'pt == prevChan' now (or NULL, if not found).
- */
-
- if (!pt) {
+ if (statePtr == NULL) {
+ Tcl_AppendResult(interp, "couldn't find state for channel \"",
+ Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
return (Tcl_Channel) NULL;
}
@@ -1236,189 +1153,93 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
* --+---+---+---+----+
*/
- if ((mask & Tcl_GetChannelMode (prevChan)) == 0) {
+ if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) {
+ Tcl_AppendResult(interp,
+ "reading and writing both disallowed for channel \"",
+ Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
return (Tcl_Channel) NULL;
}
- chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
-
/*
- * If there is some interest in the channel, remove it, break
- * down the whole chain. It will be reconstructed later.
+ * Flush the buffers. This ensures that any data still in them
+ * at this time is not handled by the new transformation. Restrict
+ * this to writable channels. Take care to hide a possible bg-copy
+ * in progress from Tcl_Flush and the CheckForChannelErrors inside.
*/
- interest = pt->interestMask;
-
- pt->interestMask = 0;
+ if ((mask & TCL_WRITABLE) != 0) {
+ CopyState *csPtr;
- if (interest) {
- (pt->typePtr->watchProc) (pt->instanceData, 0);
- }
+ csPtr = statePtr->csPtr;
+ statePtr->csPtr = (CopyState*) NULL;
- /*
- * Save some of the current state into the new structure,
- * reinitialize the parts which will stay with the transformation.
- *
- * Remarks:
- * - We cannot discard the buffers, and they cannot be used from the
- * transformation placed later into the 'pt' structure. Save them,
- * and believe that Tcl_SetChannelOption (buffering, none) will do
- * the right thing.
- * - encoding and EOL-translation control information is initialized
- * to values for 'binary'. This is later reinforced via
- * Tcl_SetChanneloption to get the handling of flags and the event
- * system right.
- * - The 'interestMask' of the saved channel is cleared, but the
- * transformations WatchProc is used to establish the connection
- * between transformation and underlying channel. This should
- * reestablish the correct mask.
- * - TTO = Transform Takes Over. The hidden channel no longer
- * needs to perform this function.
- */
-
- chanPtr->channelName = (char *) ckalloc (strlen(pt->channelName)+1);
- strcpy (chanPtr->channelName, pt->channelName);
-
- chanPtr->flags = pt->flags; /* Save */
-
- chanPtr->encoding = (Tcl_Encoding) NULL; /* == 'binary' */
- chanPtr->inputEncodingState = (Tcl_EncodingState) NULL;
- chanPtr->inputEncodingFlags = TCL_ENCODING_START;
- chanPtr->outputEncodingState = (Tcl_EncodingState) NULL;
- chanPtr->outputEncodingFlags = TCL_ENCODING_START;
-
- chanPtr->inputTranslation = TCL_TRANSLATE_LF; /* == 'binary' */
- chanPtr->outputTranslation = TCL_TRANSLATE_LF; /* == 'binary' */
- chanPtr->inEofChar = pt->inEofChar; /* Save */
- chanPtr->outEofChar = pt->outEofChar; /* Save */
-
- chanPtr->unreportedError = pt->unreportedError; /* Save */
- chanPtr->instanceData = pt->instanceData; /* Save */
- chanPtr->typePtr = pt->typePtr; /* Save */
- chanPtr->refCount = 0; /* None, as the structure is covered */
- chanPtr->closeCbPtr = (CloseCallback*) NULL; /* TTO */
-
- chanPtr->outputStage = (char*) NULL;
- chanPtr->curOutPtr = pt->curOutPtr; /* Save */
- chanPtr->outQueueHead = pt->outQueueHead; /* Save */
- chanPtr->outQueueTail = pt->outQueueTail; /* Save */
- chanPtr->saveInBufPtr = pt->saveInBufPtr; /* Save */
- chanPtr->inQueueHead = pt->inQueueHead; /* Save */
- chanPtr->inQueueTail = pt->inQueueTail; /* Save */
-
- chanPtr->chPtr = (ChannelHandler *) NULL; /* TTO */
- chanPtr->interestMask = 0;
- chanPtr->nextChanPtr = (Channel*) NULL; /* Is not in list! */
- chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL; /* TTO */
- chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
- chanPtr->timer = (Tcl_TimerToken) NULL; /* TTO */
- chanPtr->csPtr = (CopyState*) NULL; /* TTO */
-
- /*
- * Place new block at the head of a possibly existing list of previously
- * stacked channels, then do the missing initializations of translation
- * and buffer system.
- */
-
- chanPtr->supercedes = pt->supercedes;
-
- Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
- "-translation", "binary");
- Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
- "-buffering", "none");
+ if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) {
+ statePtr->csPtr = csPtr;
+ Tcl_AppendResult(interp, "could not flush channel \"",
+ Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ return (Tcl_Channel) NULL;
+ }
+ statePtr->csPtr = csPtr;
+ }
/*
- * Save accomplished, now reinitialize the (old) structure for the
- * transformation.
+ * 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.
*
- * - The information about encoding and eol-translation is taken
- * without change. There is no need to fiddle with
- * refCount et. al.
- *
- * Don't forget to use the same blocking mode as the old channel.
- */
-
- pt->flags = mask | (chanPtr->flags & CHANNEL_NONBLOCKING);
-
- /*
- * EDITORS NOTE: all the lines with "take it as is" should get
- * deleted once this code has been debugged.
+ * To preserve the information without having to read them again and
+ * to avoid problems with the location in the channel (seeking might
+ * be impossible) we move the buffers from the common state structure
+ * into the channel itself. We use the buffers in the channel below
+ * the new transformation to hold the data. In the future this allows
+ * us to write transformations which pre-read data and push the unused
+ * part back when they are going away.
*/
- /* pt->encoding, take it as is */
- /* pt->inputEncodingState, take it as is */
- /* pt->inputEncodingFlags, take it as is */
- /* pt->outputEncodingState, take it as is */
- /* pt->outputEncodingFlags, take it as is */
+ if (((mask & TCL_READABLE) != 0) &&
+ (statePtr->inQueueHead != (ChannelBuffer*) NULL)) {
+ /*
+ * Remark: It is possible that the channel buffers contain data from
+ * some earlier push-backs.
+ */
- /* pt->inputTranslation, take it as is */
- /* pt->outputTranslation, take it as is */
+ statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
+ prevChanPtr->inQueueHead = statePtr->inQueueHead;
- /*
- * No special EOF character, that condition is determined by the
- * old channel
- */
-
- pt->inEofChar = 0;
- pt->outEofChar = 0;
-
- pt->unreportedError = 0; /* No errors yet */
- pt->instanceData = instanceData; /* Transformation state */
- pt->typePtr = typePtr; /* Transformation type */
- /* pt->refCount, take it as it is */
- /* pt->closeCbPtr, take it as it is */
-
- /* pt->outputStage, take it as it is */
- pt->curOutPtr = (ChannelBuffer *) NULL;
- pt->outQueueHead = (ChannelBuffer *) NULL;
- pt->outQueueTail = (ChannelBuffer *) NULL;
- pt->saveInBufPtr = (ChannelBuffer *) NULL;
- pt->inQueueHead = (ChannelBuffer *) NULL;
- pt->inQueueTail = (ChannelBuffer *) NULL;
-
- /* pt->chPtr, take it as it is */
- /* pt->interestMask, take it as it is */
- /* pt->nextChanPtr, take it as it is */
- /* pt->scriptRecordPtr, take it as it is */
- pt->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
- /* pt->timer, take it as it is */
- /* pt->csPtr, take it as it is */
+ if (prevChanPtr->inQueueTail == (ChannelBuffer*) NULL) {
+ prevChanPtr->inQueueTail = statePtr->inQueueTail;
+ }
- /*
- * Have the transformation reference the new structure containing
- * the saved channel.
- */
+ statePtr->inQueueHead = (ChannelBuffer*) NULL;
+ statePtr->inQueueTail = (ChannelBuffer*) NULL;
+ }
- pt->supercedes = chanPtr;
+ chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
/*
- * Don't forget to reinitialize the output buffer used for encodings.
+ * Save some of the current state into the new structure,
+ * reinitialize the parts which will stay with the transformation.
+ *
+ * Remarks:
*/
- if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
- chanPtr->outputStage = (char *)
- ckalloc((unsigned) (chanPtr->bufSize + 2));
- }
+ chanPtr->state = statePtr;
+ chanPtr->instanceData = instanceData;
+ chanPtr->typePtr = typePtr;
+ chanPtr->downChanPtr = prevChanPtr;
+ chanPtr->upChanPtr = (Channel *) NULL;
+ chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+ chanPtr->inQueueTail = (ChannelBuffer*) NULL;
/*
- * Event handling: If the information in the old channel shows
- * that there was interest in some events call the 'WatchProc'
- * of the transformation to establish the proper connection
- * between them.
+ * Place new block at the head of a possibly existing list of previously
+ * stacked channels.
*/
- if (interest) {
- (pt->typePtr->watchProc) (pt->instanceData, interest);
- }
-
- /*
- * The superceded channel is effectively unregistered
- * We cannot decrement its reference count because that
- * can cause it to get garbage collected out from under us.
- * Don't add the following code:
- *
- * chanPtr->supercedes->refCount --;
- */
+ prevChanPtr->upChanPtr = chanPtr;
+ statePtr->topChanPtr = chanPtr;
return (Tcl_Channel) chanPtr;
}
@@ -1430,207 +1251,142 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
*
* Unstacks an entry in the hash table for a Tcl_Channel
* record. This is the reverse to 'Tcl_StackChannel'.
- * The old, superceded channel is uncovered and re-registered
- * in the appropriate data structures.
*
* Results:
- * Returns the old Tcl_Channel, i.e. the one which was stacked over.
+ * A standard Tcl result.
*
* Side effects:
- * See above.
+ * If TCL_ERROR is returned, the posix error code will be set
+ * with Tcl_SetErrno.
*
*----------------------------------------------------------------------
*/
-void
+int
Tcl_UnstackChannel (interp, chan)
- Tcl_Interp* interp; /* The interpreter we are working in */
+ Tcl_Interp *interp; /* The interpreter we are working in */
Tcl_Channel chan; /* The channel to unstack */
{
- Channel* chanPtr = (Channel*) chan;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state;
+ int result = 0;
- if (chanPtr->supercedes != (Channel*) NULL) {
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ if (chanPtr->downChanPtr != (Channel *) NULL) {
/*
* Instead of manipulating the per-thread / per-interp list/hashtable
* of registered channels we wind down the state of the transformation,
* and then restore the state of underlying channel into the old
* structure.
*/
-
- Tcl_DString dsTrans; /* storage to save option information */
- Tcl_DString dsBuf; /* storage to save option information */
- Channel top; /* Save area for current transformation */
- Channel* chanDownPtr = chanPtr->supercedes;
- int interest; /* interest mask of transformation
- * before destruct. */
- int saveInputEncodingFlags; /* Save area for encoding */
- int saveOutputEncodingFlags; /* related information */
- Tcl_EncodingState saveInputEncodingState;
- Tcl_EncodingState saveOutputEncodingState;
- Tcl_Encoding saveEncoding;
+ Channel *downChanPtr = chanPtr->downChanPtr;
/*
- * Event handling: Disallow the delivery of events from the
- * old, now uncovered channel to the transformation.
- *
- * This is done before everything else to avoid problems
- * after our heavy-duty shuffling of pointers around.
+ * Flush the buffers. This ensures that any data still in them
+ * at this time _is_ handled by the transformation we are unstacking
+ * right now. Restrict this to writable channels. Take care to hide
+ * a possible bg-copy in progress from Tcl_Flush and the
+ * CheckForChannelErrors inside.
*/
- interest = chanPtr->interestMask;
- (chanPtr->typePtr->watchProc) (chanPtr->instanceData, 0);
-
- /* 1. Swap the information in the top channel (the transformation)
- * and the channel below, with some exceptions. This additionally
- * cuts the top channel out of the chain. Without the latter
- * a Tcl_Close on the transformation would be impossible, as that
- * procedure will free the structure, making 'top' unusable.
- *
- * chanPtr -> top channel, transformation.
- * chanDownPtr -> channel immediately below the transformation.
- */
+ if (statePtr->flags & TCL_WRITABLE) {
+ CopyState* csPtr;
- memcpy ((void*) &top, (void*) chanPtr, sizeof (Channel));
- memcpy ((void*) chanPtr, (void*) chanDownPtr, sizeof (Channel));
- top.supercedes = (Channel*) NULL;
- memcpy ((void*) chanDownPtr, (void*) &top, sizeof (Channel));
-
- /* Now:
- * chanPtr -> channel immediately below the transformation, now top
- * chanDownPtr -> transformation, cut loose.
- *
- * Handle the exceptions mentioned above, i.e. move the information
- * from the transformation into the new top, and reinitialize it to
- * safe values in the transformation.
- */
-
- chanPtr->refCount = chanDownPtr->refCount;
- chanPtr->closeCbPtr = chanDownPtr->closeCbPtr;
- chanPtr->chPtr = chanDownPtr->chPtr;
- chanPtr->nextChanPtr = chanDownPtr->nextChanPtr;
- chanPtr->scriptRecordPtr = chanDownPtr->scriptRecordPtr;
- chanPtr->timer = chanDownPtr->timer;
- chanPtr->csPtr = chanDownPtr->csPtr;
-
- chanDownPtr->refCount = 0;
- chanDownPtr->closeCbPtr = (CloseCallback*) NULL;
- chanDownPtr->chPtr = (ChannelHandler*) NULL;
- chanDownPtr->nextChanPtr = (Channel*) NULL;
- chanDownPtr->scriptRecordPtr = (EventScriptRecord*) NULL;
- chanDownPtr->timer = (Tcl_TimerToken) NULL;
- chanDownPtr->csPtr = (CopyState*) NULL;
-
- /* The now uncovered channel still has encoding and eol-translation
- * deactivated, i.e. switched to 'binary'. *Don't* touch this until
- * after the transformation is closed for good, as it may write
- * information into it during that (-> flushing of data waiting in
- * internal buffers!) and rely on these settings. Thanks to Matt
- * Newman <matt@sensus.org> for finding this goof.
- *
- * But we also have to protect the state of the encoding from removal
- * during the close. So we save it in some local variables.
- * Additionally the current value of the options is lost after we
- * close, we have to save them now.
- */
+ csPtr = statePtr->csPtr;
+ statePtr->csPtr = (CopyState*) NULL;
- saveEncoding = chanDownPtr->encoding;
- saveInputEncodingState = chanDownPtr->inputEncodingState;
- saveInputEncodingFlags = chanDownPtr->inputEncodingFlags;
- saveOutputEncodingState = chanDownPtr->outputEncodingState;
- saveOutputEncodingFlags = chanDownPtr->outputEncodingFlags;
-
- Tcl_DStringInit (&dsTrans);
- Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr,
- "-translation", &dsTrans);
+ if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
+ statePtr->csPtr = csPtr;
+ Tcl_AppendResult(interp, "could not flush channel \"",
+ Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
+ (char *) NULL);
+ return TCL_ERROR;
+ }
- Tcl_DStringInit (&dsBuf);
- Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr,
- "-buffering", &dsBuf);
+ statePtr->csPtr = csPtr;
+ }
/*
- * Prevent the accidential removal of the encoding during
- * the destruction of the transformation channel.
+ * Anything in the input queue and the push-back buffers of
+ * the transformation going away is transformed data, but not
+ * yet read. As unstacking means that the caller does not want
+ * to see transformed data any more we have to discard these
+ * bytes. To avoid writing an analogue to 'DiscardInputQueued'
+ * we move the information in the push back buffers to the
+ * input queue and then call 'DiscardInputQueued' on that.
*/
- chanDownPtr->encoding = (Tcl_Encoding) NULL;
- chanDownPtr->inputEncodingState = (Tcl_EncodingState) NULL;
- chanDownPtr->inputEncodingFlags = TCL_ENCODING_START;
- chanDownPtr->outputEncodingState = (Tcl_EncodingState) NULL;
- chanDownPtr->outputEncodingFlags = TCL_ENCODING_START;
+ if (((statePtr->flags & TCL_READABLE) != 0) &&
+ ((statePtr->inQueueHead != (ChannelBuffer*) NULL) ||
+ (chanPtr->inQueueHead != (ChannelBuffer*) NULL))) {
- /*
- * A little trick: Add the transformation structure to the
- * per-thread list of existing channels (which it never were
- * part of so far), or Tcl_Close/FlushChannel will panic
- * ("damaged channel list").
- *
- * Afterward do a regular close upon the transformation.
- * This may cause flushing of data into the old channel (if the
- * transformation remembered its own channel in itself).
- *
- * We know that its refCount dropped to 0.
- */
+ if ((statePtr->inQueueHead != (ChannelBuffer*) NULL) &&
+ (chanPtr->inQueueHead != (ChannelBuffer*) NULL)) {
+ statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
+ statePtr->inQueueTail = chanPtr->inQueueTail;
+ statePtr->inQueueHead = statePtr->inQueueTail;
+
+ } else if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
+ statePtr->inQueueHead = chanPtr->inQueueHead;
+ statePtr->inQueueTail = chanPtr->inQueueTail;
+ }
+
+ chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+ chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+
+ DiscardInputQueued (statePtr, 0);
+ }
- Tcl_SpliceChannel ((Tcl_Channel) chanDownPtr);
- Tcl_Close (interp, (Tcl_Channel) chanDownPtr);
+ statePtr->topChanPtr = downChanPtr;
+ downChanPtr->upChanPtr = (Channel *) NULL;
/*
- * Now it is possible to wind down the transformation (in 'top'),
- * especially to copy the current encoding and translation control
- * information down.
+ * Leave this link intact for closeproc
+ * chanPtr->downChanPtr = (Channel *) NULL;
*/
-
+
/*
- * Move the currently active encoding from the save area
- * to the now uncovered channel. We assume here that this
- * channel uses 'encoding binary' (==> encoding == NULL, etc.
- * This allows us to simply copy the pointers without having to
- * think about refcounts and deallocation of the old encoding.
- *
- * And don't forget to reenable the EOL-translation used by the
- * transformation. Using a DString to do this *is* a bit awkward,
- * but still the best way to handle the complexities here, like
- * flag manipulation and event system.
+ * Close and free the channel driver state.
*/
- chanPtr->encoding = saveEncoding;
- chanPtr->inputEncodingState = saveInputEncodingState;
- chanPtr->inputEncodingFlags = saveInputEncodingFlags;
- chanPtr->outputEncodingState = saveOutputEncodingState;
- chanPtr->outputEncodingFlags = saveOutputEncodingFlags;
-
- Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
- "-translation", dsTrans.string);
-
- Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr,
- "-buffering", dsBuf.string);
-
- Tcl_DStringFree (&dsTrans);
- Tcl_DStringFree (&dsBuf);
+ if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
+ result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData,
+ interp);
+ } else {
+ result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
+ interp, 0);
+ }
+ chanPtr->typePtr = NULL;
/*
- * Event handling: If the information from the now destroyed
- * transformation shows that there was interest in some events
- * call the 'WatchProc' of the now uncovered channel to renew
- * that interest with underlying channels or the driver.
+ * AK: Tcl_NotifyChannel may hold a reference to this block of memory
*/
+ Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+ UpdateInterest(downChanPtr);
- if (interest) {
- chanPtr->interestMask = 0;
- (chanPtr->typePtr->watchProc) (chanPtr->instanceData,
- interest);
- chanPtr->interestMask = interest;
+ if (result != 0) {
+ Tcl_SetErrno(result);
+ return TCL_ERROR;
}
-
} else {
- /* This channel does not cover another one.
+ /*
+ * This channel does not cover another one.
* Simply do a close, if necessary.
*/
- if (chanPtr->refCount == 0) {
- Tcl_Close (interp, chan);
+ if (statePtr->refCount <= 0) {
+ if (Tcl_Close(interp, chan) != TCL_OK) {
+ return TCL_ERROR;
+ }
}
}
+
+ return TCL_OK;
}
/*
@@ -1638,7 +1394,7 @@ Tcl_UnstackChannel (interp, chan)
*
* Tcl_GetStackedChannel --
*
- * Determines wether the specified channel is stacked upon another.
+ * Determines whether the specified channel is stacked upon another.
*
* Results:
* NULL if the channel is not stacked upon another one, or a reference
@@ -1655,20 +1411,22 @@ Tcl_Channel
Tcl_GetStackedChannel(chan)
Tcl_Channel chan;
{
- Channel* chanPtr = (Channel*) chan;
- return (Tcl_Channel) chanPtr->supercedes;
+ Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+
+ return (Tcl_Channel) chanPtr->downChanPtr;
}
/*
*----------------------------------------------------------------------
*
- * Tcl_GetChannelMode --
+ * Tcl_GetTopChannel --
*
- * Computes a mask indicating whether the channel is open for
- * reading and writing.
+ * Returns the top channel of a channel stack.
*
* Results:
- * An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
+ * NULL if the channel is not stacked upon another one, or a reference
+ * to the channel it is stacked upon. This reference can be used in
+ * queries, but modification is not allowed.
*
* Side effects:
* None.
@@ -1676,28 +1434,24 @@ Tcl_GetStackedChannel(chan)
*----------------------------------------------------------------------
*/
-int
-Tcl_GetChannelMode(chan)
- Tcl_Channel chan; /* The channel for which the mode is
- * being computed. */
+Tcl_Channel
+Tcl_GetTopChannel(chan)
+ Tcl_Channel chan;
{
- Channel *chanPtr; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan; /* The actual channel. */
- chanPtr = (Channel *) chan;
- return (chanPtr->flags & (TCL_READABLE | TCL_WRITABLE));
+ return (Tcl_Channel) chanPtr->state->topChanPtr;
}
/*
*----------------------------------------------------------------------
*
- * Tcl_GetChannelName --
+ * Tcl_GetChannelInstanceData --
*
- * Returns the string identifying the channel name.
+ * Returns the client data associated with a channel.
*
* Results:
- * The string containing the channel name. This memory is
- * owned by the generic layer and should not be modified by
- * the caller.
+ * The client data.
*
* Side effects:
* None.
@@ -1705,14 +1459,13 @@ Tcl_GetChannelMode(chan)
*----------------------------------------------------------------------
*/
-char *
-Tcl_GetChannelName(chan)
- Tcl_Channel chan; /* The channel for which to return the name. */
+ClientData
+Tcl_GetChannelInstanceData(chan)
+ Tcl_Channel chan; /* Channel for which to return client data. */
{
- Channel *chanPtr; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan; /* The actual channel. */
- chanPtr = (Channel *) chan;
- return chanPtr->channelName;
+ return chanPtr->instanceData;
}
/*
@@ -1735,22 +1488,21 @@ Tcl_ChannelType *
Tcl_GetChannelType(chan)
Tcl_Channel chan; /* The channel to return type for. */
{
- Channel *chanPtr; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan; /* The actual channel. */
- chanPtr = (Channel *) chan;
return chanPtr->typePtr;
}
/*
*----------------------------------------------------------------------
*
- * Tcl_GetChannelHandle --
+ * Tcl_GetChannelMode --
*
- * Returns an OS handle associated with a channel.
+ * Computes a mask indicating whether the channel is open for
+ * reading and writing.
*
* Results:
- * Returns TCL_OK and places the handle in handlePtr, or returns
- * TCL_ERROR on failure.
+ * An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
*
* Side effects:
* None.
@@ -1759,33 +1511,27 @@ Tcl_GetChannelType(chan)
*/
int
-Tcl_GetChannelHandle(chan, direction, handlePtr)
- Tcl_Channel chan; /* The channel to get file from. */
- int direction; /* TCL_WRITABLE or TCL_READABLE. */
- ClientData *handlePtr; /* Where to store handle */
+Tcl_GetChannelMode(chan)
+ Tcl_Channel chan; /* The channel for which the mode is
+ * being computed. */
{
- Channel *chanPtr; /* The actual channel. */
- ClientData handle;
- int result;
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of actual channel. */
- chanPtr = (Channel *) chan;
- result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
- direction, &handle);
- if (handlePtr) {
- *handlePtr = handle;
- }
- return result;
+ return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE));
}
/*
*----------------------------------------------------------------------
*
- * Tcl_GetChannelInstanceData --
+ * Tcl_GetChannelName --
*
- * Returns the client data associated with a channel.
+ * Returns the string identifying the channel name.
*
* Results:
- * The client data.
+ * The string containing the channel name. This memory is
+ * owned by the generic layer and should not be modified by
+ * the caller.
*
* Side effects:
* None.
@@ -1793,14 +1539,50 @@ Tcl_GetChannelHandle(chan, direction, handlePtr)
*----------------------------------------------------------------------
*/
-ClientData
-Tcl_GetChannelInstanceData(chan)
- Tcl_Channel chan; /* Channel for which to return client data. */
+char *
+Tcl_GetChannelName(chan)
+ Tcl_Channel chan; /* The channel for which to return the name. */
+{
+ ChannelState *statePtr; /* State of actual channel. */
+
+ statePtr = ((Channel *) chan)->state;
+ return statePtr->channelName;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelHandle --
+ *
+ * Returns an OS handle associated with a channel.
+ *
+ * Results:
+ * Returns TCL_OK and places the handle in handlePtr, or returns
+ * TCL_ERROR on failure.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelHandle(chan, direction, handlePtr)
+ Tcl_Channel chan; /* The channel to get file from. */
+ int direction; /* TCL_WRITABLE or TCL_READABLE. */
+ ClientData *handlePtr; /* Where to store handle */
{
Channel *chanPtr; /* The actual channel. */
+ ClientData handle;
+ int result;
- chanPtr = (Channel *) chan;
- return chanPtr->instanceData;
+ chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
+ direction, &handle);
+ if (handlePtr) {
+ *handlePtr = handle;
+ }
+ return result;
}
/*
@@ -1865,8 +1647,8 @@ AllocChannelBuffer(length)
*/
static void
-RecycleBuffer(chanPtr, bufPtr, mustDiscard)
- Channel *chanPtr; /* Channel for which to recycle buffers. */
+RecycleBuffer(statePtr, bufPtr, mustDiscard)
+ ChannelState *statePtr; /* ChannelState in which to recycle buffers. */
ChannelBuffer *bufPtr; /* The buffer to recycle. */
int mustDiscard; /* If nonzero, free the buffer to the
* OS, always. */
@@ -1879,19 +1661,19 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
ckfree((char *) bufPtr);
return;
}
-
+
/*
* Only save buffers for the input queue if the channel is readable.
*/
- if (chanPtr->flags & TCL_READABLE) {
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->inQueueHead = bufPtr;
- chanPtr->inQueueTail = bufPtr;
+ if (statePtr->flags & TCL_READABLE) {
+ if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->inQueueHead = bufPtr;
+ statePtr->inQueueTail = bufPtr;
goto keepit;
}
- if (chanPtr->saveInBufPtr == (ChannelBuffer *) NULL) {
- chanPtr->saveInBufPtr = bufPtr;
+ if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) {
+ statePtr->saveInBufPtr = bufPtr;
goto keepit;
}
}
@@ -1900,9 +1682,9 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
* Only save buffers for the output queue if the channel is writable.
*/
- if (chanPtr->flags & TCL_WRITABLE) {
- if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
- chanPtr->curOutPtr = bufPtr;
+ if (statePtr->flags & TCL_WRITABLE) {
+ if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+ statePtr->curOutPtr = bufPtr;
goto keepit;
}
}
@@ -1914,7 +1696,7 @@ RecycleBuffer(chanPtr, bufPtr, mustDiscard)
ckfree((char *) bufPtr);
return;
-keepit:
+ keepit:
bufPtr->nextRemoved = BUFFER_PADDING;
bufPtr->nextAdded = BUFFER_PADDING;
bufPtr->nextPtr = (ChannelBuffer *) NULL;
@@ -1937,18 +1719,18 @@ keepit:
*/
static void
-DiscardOutputQueued(chanPtr)
- Channel *chanPtr; /* The channel for which to discard output. */
+DiscardOutputQueued(statePtr)
+ ChannelState *statePtr; /* ChannelState for which to discard output. */
{
ChannelBuffer *bufPtr;
- while (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
- bufPtr = chanPtr->outQueueHead;
- chanPtr->outQueueHead = bufPtr->nextPtr;
- RecycleBuffer(chanPtr, bufPtr, 0);
+ while (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
+ bufPtr = statePtr->outQueueHead;
+ statePtr->outQueueHead = bufPtr->nextPtr;
+ RecycleBuffer(statePtr, bufPtr, 0);
}
- chanPtr->outQueueHead = (ChannelBuffer *) NULL;
- chanPtr->outQueueTail = (ChannelBuffer *) NULL;
+ statePtr->outQueueHead = (ChannelBuffer *) NULL;
+ statePtr->outQueueTail = (ChannelBuffer *) NULL;
}
/*
@@ -1969,16 +1751,16 @@ DiscardOutputQueued(chanPtr)
*/
static int
-CheckForDeadChannel(interp, chanPtr)
+CheckForDeadChannel(interp, statePtr)
Tcl_Interp *interp; /* For error reporting (can be NULL) */
- Channel *chanPtr; /* The channel to check. */
+ ChannelState *statePtr; /* The channel state to check. */
{
- if (chanPtr->flags & CHANNEL_DEAD) {
+ if (statePtr->flags & CHANNEL_DEAD) {
Tcl_SetErrno(EINVAL);
if (interp) {
Tcl_AppendResult(interp,
- "unable to access channel: invalid channel",
- (char *) NULL);
+ "unable to access channel: invalid channel",
+ (char *) NULL);
}
return 1;
}
@@ -2014,6 +1796,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* called from an asynchronous
* flush callback. */
{
+ ChannelState *statePtr = chanPtr->state;
+ /* State of the channel stack. */
ChannelBuffer *bufPtr; /* Iterates over buffered output
* queue. */
int toWrite; /* Amount of output data in current
@@ -2032,7 +1816,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* all interpreters.
*/
- if (CheckForDeadChannel(interp,chanPtr)) return -1;
+ if (CheckForDeadChannel(interp, statePtr)) return -1;
/*
* Loop over the queued buffers and attempt to flush as
@@ -2046,22 +1830,22 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* the current buffer is full, then move the current buffer to the
* queue.
*/
-
- if (((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (chanPtr->curOutPtr->nextAdded == chanPtr->curOutPtr->bufLength))
- || ((chanPtr->flags & BUFFER_READY) &&
- (chanPtr->outQueueHead == (ChannelBuffer *) NULL))) {
- chanPtr->flags &= (~(BUFFER_READY));
- chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
- if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->outQueueHead = chanPtr->curOutPtr;
+
+ if (((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ (statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
+ || ((statePtr->flags & BUFFER_READY) &&
+ (statePtr->outQueueHead == (ChannelBuffer *) NULL))) {
+ statePtr->flags &= (~(BUFFER_READY));
+ statePtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
+ if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->outQueueHead = statePtr->curOutPtr;
} else {
- chanPtr->outQueueTail->nextPtr = chanPtr->curOutPtr;
+ statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
}
- chanPtr->outQueueTail = chanPtr->curOutPtr;
- chanPtr->curOutPtr = (ChannelBuffer *) NULL;
+ statePtr->outQueueTail = statePtr->curOutPtr;
+ statePtr->curOutPtr = (ChannelBuffer *) NULL;
}
- bufPtr = chanPtr->outQueueHead;
+ bufPtr = statePtr->outQueueHead;
/*
* If we are not being called from an async flush and an async
@@ -2069,7 +1853,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if ((!calledFromAsyncFlush) &&
- (chanPtr->flags & BG_FLUSH_SCHEDULED)) {
+ (statePtr->flags & BG_FLUSH_SCHEDULED)) {
return 0;
}
@@ -2084,12 +1868,12 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
/*
* Produce the output on the channel.
*/
-
+
toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
(char *) bufPtr->buf + bufPtr->nextRemoved, toWrite,
&errorCode);
-
+
/*
* If the write failed completely attempt to start the asynchronous
* flush mechanism and break out of this loop - do not attempt to
@@ -2119,8 +1903,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* that setting stdin to -blocking 0 has some effect on
* the stdout when it's a tty channel (dup'ed underneath)
*/
- if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
- chanPtr->flags |= BG_FLUSH_SCHEDULED;
+ if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
+ statePtr->flags |= BG_FLUSH_SCHEDULED;
UpdateInterest(chanPtr);
}
errorCode = 0;
@@ -2132,8 +1916,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if (calledFromAsyncFlush) {
- if (chanPtr->unreportedError == 0) {
- chanPtr->unreportedError = errorCode;
+ if (statePtr->unreportedError == 0) {
+ statePtr->unreportedError = errorCode;
}
} else {
Tcl_SetErrno(errorCode);
@@ -2148,7 +1932,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* currently queued.
*/
- DiscardOutputQueued(chanPtr);
+ DiscardOutputQueued(statePtr);
continue;
} else {
wroteSome = 1;
@@ -2161,11 +1945,11 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
- chanPtr->outQueueHead = bufPtr->nextPtr;
- if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->outQueueTail = (ChannelBuffer *) NULL;
+ statePtr->outQueueHead = bufPtr->nextPtr;
+ if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->outQueueTail = (ChannelBuffer *) NULL;
}
- RecycleBuffer(chanPtr, bufPtr, 0);
+ RecycleBuffer(statePtr, bufPtr, 0);
}
} /* Closes "while (1)". */
@@ -2176,13 +1960,13 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* pending data has been flushed at the system level.
*/
- if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
+ if (statePtr->flags & BG_FLUSH_SCHEDULED) {
if (wroteSome) {
return errorCode;
- } else if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
+ } else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
- chanPtr->interestMask);
+ statePtr->interestMask);
}
}
@@ -2192,12 +1976,12 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* in the current output buffer.
*/
- if ((chanPtr->flags & CHANNEL_CLOSED) && (chanPtr->refCount <= 0) &&
- (chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
- ((chanPtr->curOutPtr == (ChannelBuffer *) NULL) ||
- (chanPtr->curOutPtr->nextAdded ==
- chanPtr->curOutPtr->nextRemoved))) {
- return CloseChannel(interp, chanPtr, errorCode);
+ if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
+ (statePtr->outQueueHead == (ChannelBuffer *) NULL) &&
+ ((statePtr->curOutPtr == (ChannelBuffer *) NULL) ||
+ (statePtr->curOutPtr->nextAdded ==
+ statePtr->curOutPtr->nextRemoved))) {
+ return CloseChannel(interp, chanPtr, errorCode);
}
return errorCode;
}
@@ -2207,14 +1991,21 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*
* CloseChannel --
*
- * Utility procedure to close a channel and free its associated
- * resources.
+ * Utility procedure to close a channel and free associated resources.
+ *
+ * If the channel was stacked, then the it will copy the necessary
+ * elements of the NEXT channel into the TOP channel, in essence
+ * unstacking the channel. The NEXT channel will then be freed.
+ *
+ * If the channel was not stacked, then we will free all the bits
+ * for the TOP channel, including the data structure itself.
*
* Results:
- * 0 on success or a POSIX error code if the operation failed.
+ * 1 if the channel was stacked, 0 otherwise.
*
* Side effects:
* May close the actual channel; may free memory.
+ * May change the value of errno.
*
*----------------------------------------------------------------------
*/
@@ -2227,24 +2018,27 @@ CloseChannel(interp, chanPtr, errorCode)
{
int result = 0; /* Of calling driver close
* operation. */
+ ChannelState *statePtr; /* state of the channel stack. */
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if (chanPtr == NULL) {
return result;
}
-
+ statePtr = chanPtr->state;
+
/*
* No more input can be consumed so discard any leftover input.
*/
- DiscardInputQueued(chanPtr, 1);
+ DiscardInputQueued(statePtr, 1);
/*
* Discard a leftover buffer in the current output buffer field.
*/
- if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
- ckfree((char *) chanPtr->curOutPtr);
- chanPtr->curOutPtr = (ChannelBuffer *) NULL;
+ if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
+ ckfree((char *) statePtr->curOutPtr);
+ statePtr->curOutPtr = (ChannelBuffer *) NULL;
}
/*
@@ -2252,7 +2046,7 @@ CloseChannel(interp, chanPtr, errorCode)
* queued for output.
*/
- if (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
+ if (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
panic("TclFlush, closed channel: queued output left");
}
@@ -2261,52 +2055,56 @@ CloseChannel(interp, chanPtr, errorCode)
* output device.
*/
- if ((chanPtr->outEofChar != 0) && (chanPtr->flags & TCL_WRITABLE)) {
+ if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) {
int dummy;
char c;
- c = (char) chanPtr->outEofChar;
+ c = (char) statePtr->outEofChar;
(chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
}
/*
- * Remove TCL_READABLE and TCL_WRITABLE from chanPtr->flags, so
- * that close callbacks can not do input or output (assuming they
- * squirreled the channel away in their clientData). This also
- * prevents infinite loops if the callback calls any C API that
- * could call FlushChannel.
+ * Remove this channel from of the list of all channels.
*/
-
- chanPtr->flags &= (~(TCL_READABLE|TCL_WRITABLE));
-
- Tcl_CutChannel ((Tcl_Channel) chanPtr);
+ Tcl_CutChannel((Tcl_Channel) chanPtr);
/*
* Close and free the channel driver state.
*/
-
+
if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp);
} else {
result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
0);
}
-
- if (chanPtr->channelName != (char *) NULL) {
- ckfree(chanPtr->channelName);
- }
- Tcl_FreeEncoding(chanPtr->encoding);
- if (chanPtr->outputStage != NULL) {
- ckfree((char *) chanPtr->outputStage);
+
+ /*
+ * Some resources can be cleared only if the bottom channel
+ * in a stack is closed. All the other channels in the stack
+ * are not allowed to remove.
+ */
+
+ if (chanPtr == statePtr->bottomChanPtr) {
+ if (statePtr->channelName != (char *) NULL) {
+ ckfree(statePtr->channelName);
+ statePtr->channelName = NULL;
+ }
+
+ Tcl_FreeEncoding(statePtr->encoding);
+ if (statePtr->outputStage != NULL) {
+ ckfree((char *) statePtr->outputStage);
+ statePtr->outputStage = (char *) NULL;
+ }
}
-
+
/*
* If we are being called synchronously, report either
* any latent error on the channel or the current error.
*/
-
- if (chanPtr->unreportedError != 0) {
- errorCode = chanPtr->unreportedError;
+
+ if (statePtr->unreportedError != 0) {
+ errorCode = statePtr->unreportedError;
}
if (errorCode == 0) {
errorCode = result;
@@ -2315,51 +2113,34 @@ CloseChannel(interp, chanPtr, errorCode)
}
}
- /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998
- * "Trf-Patch for filtering channels"
- *
- * This is the change to 'CloseChannel'.
- *
- * Explanation
- * Closing a filtering channel closes the one it
- * superceded too. This basically ripples through
- * the whole chain of filters until it reaches
- * the underlying normal channel.
- *
- * This is done by reintegrating the superceded
- * channel into the (thread) global list of open
- * channels and then invoking a regular close.
- * There is no need to handle the complexities of
- * this process by ourselves.
- *
- * *Note*
- * This has to be done after the call to the
- * 'closeProc' of the filtering channel to allow
- * that one to flush internal buffers into
- * the underlying channel.
- */
-
- if (chanPtr->supercedes != (Channel*) NULL) {
- /*
- * Insert the channel we were stacked upon back into
- * the list of open channels, then do a regular close.
- */
-
- Tcl_SpliceChannel ((Tcl_Channel) chanPtr->supercedes);
- chanPtr->supercedes->refCount --; /* is deregistered */
- Tcl_Close (interp, (Tcl_Channel) chanPtr->supercedes);
- }
-
/*
* Cancel any outstanding timer.
*/
- Tcl_DeleteTimerHandler(chanPtr->timer);
+ Tcl_DeleteTimerHandler(statePtr->timer);
/*
* Mark the channel as deleted by clearing the type structure.
*/
+ if (chanPtr->downChanPtr != (Channel *) NULL) {
+ Channel *downChanPtr = chanPtr->downChanPtr;
+
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
+
+ statePtr->topChanPtr = downChanPtr;
+ downChanPtr->upChanPtr = (Channel *) NULL;
+ chanPtr->typePtr = NULL;
+
+ Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
+ return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
+ }
+
+ /*
+ * There is only the TOP Channel, so we free the remaining
+ * pointers we have and then ourselves.
+ */
chanPtr->typePtr = NULL;
Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
@@ -2373,19 +2154,20 @@ CloseChannel(interp, chanPtr, errorCode)
* Tcl_CutChannel --
*
* Removes a channel from the (thread-)global list of all channels
- * (in that thread).
+ * (in that thread). This is actually the statePtr for the stack
+ * of channel.
*
* Results:
* Nothing.
*
* Side effects:
- * Resets the field 'nextChanPtr' of the specified channel to NULL.
+ * Resets the field 'nextCSPtr' of the specified channel state to NULL.
*
* NOTE:
* The channel to splice out of the list must not be referenced
* in any interpreter. This is something this procedure cannot
* check (despite the refcount) because the caller usually wants
- * figgle with the channel (like transfering it to a different
+ * fiddle with the channel (like transfering it to a different
* thread) and thus keeps the refcount artifically high to prevent
* its destruction.
*
@@ -2393,38 +2175,38 @@ CloseChannel(interp, chanPtr, errorCode)
*/
void
-Tcl_CutChannel (chan)
+Tcl_CutChannel(chan)
Tcl_Channel chan; /* The channel being removed. Must
* not be referenced in any
* interpreter. */
{
ThreadSpecificData* tsdPtr = TCL_TSD_INIT(&dataKey);
- Channel* chanPtr = (Channel *) chan;
- Channel* prevChanPtr; /* Preceding channel in list of
- * all channels - used to splice a
+ ChannelState *prevCSPtr; /* Preceding channel state in list of
+ * all states - used to splice a
* channel out of the list on close. */
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* state of the channel stack. */
/*
- * Splice this channel out of the list of all channels (in the current
- * thread).
+ * Remove this channel from of the list of all channels
+ * (in the current thread).
*/
- if (chanPtr == tsdPtr->firstChanPtr) {
- tsdPtr->firstChanPtr = chanPtr->nextChanPtr;
+ if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
+ tsdPtr->firstCSPtr = statePtr->nextCSPtr;
} else {
- for (prevChanPtr = tsdPtr->firstChanPtr;
- (prevChanPtr != (Channel *) NULL) &&
- (prevChanPtr->nextChanPtr != chanPtr);
- prevChanPtr = prevChanPtr->nextChanPtr) {
+ for (prevCSPtr = tsdPtr->firstCSPtr;
+ prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+ prevCSPtr = prevCSPtr->nextCSPtr) {
/* Empty loop body. */
}
- if (prevChanPtr == (Channel *) NULL) {
+ if (prevCSPtr == (ChannelState *) NULL) {
panic("FlushChannel: damaged channel list");
}
- prevChanPtr->nextChanPtr = chanPtr->nextChanPtr;
+ prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
}
- chanPtr->nextChanPtr = (Channel *) NULL;
+ statePtr->nextCSPtr = (ChannelState *) NULL;
}
/*
@@ -2454,20 +2236,20 @@ Tcl_CutChannel (chan)
*/
void
-Tcl_SpliceChannel (chan)
+Tcl_SpliceChannel(chan)
Tcl_Channel chan; /* The channel being added. Must
* not be referenced in any
* interpreter. */
{
- ThreadSpecificData* tsdPtr = TCL_TSD_INIT(&dataKey);
- Channel* chanPtr = (Channel *) chan;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *statePtr = ((Channel *) chan)->state;
- if (chanPtr->nextChanPtr != (Channel *) NULL) {
+ if (statePtr->nextCSPtr != (ChannelState *) NULL) {
panic("Tcl_SpliceChannel: trying to add channel used in different list");
}
- chanPtr->nextChanPtr = tsdPtr->firstChanPtr;
- tsdPtr->firstChanPtr = chanPtr;
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
}
/*
@@ -2503,12 +2285,13 @@ Tcl_Close(interp, chan)
CloseCallback *cbPtr; /* Iterate over close callbacks
* for this channel. */
Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of real IO channel. */
int result; /* Of calling FlushChannel. */
if (chan == (Tcl_Channel) NULL) {
return TCL_OK;
}
-
+
/*
* Perform special handling for standard channels being closed. If the
* refCount is now 1 it means that the last reference to the standard
@@ -2519,20 +2302,27 @@ Tcl_Close(interp, chan)
CheckForStdChannelsBeingClosed(chan);
- chanPtr = (Channel *) chan;
- if (chanPtr->refCount > 0) {
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = (Channel *) chan;
+ statePtr = chanPtr->state;
+ chanPtr = statePtr->topChanPtr;
+
+ if (statePtr->refCount > 0) {
panic("called Tcl_Close on channel with refCount > 0");
}
- Tcl_ClearChannelHandlers (chan);
-
+ Tcl_ClearChannelHandlers(chan);
+
/*
* Invoke the registered close callbacks and delete their records.
*/
- while (chanPtr->closeCbPtr != (CloseCallback *) NULL) {
- cbPtr = chanPtr->closeCbPtr;
- chanPtr->closeCbPtr = cbPtr->nextPtr;
+ while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
+ cbPtr = statePtr->closeCbPtr;
+ statePtr->closeCbPtr = cbPtr->nextPtr;
(cbPtr->proc) (cbPtr->clientData);
ckfree((char *) cbPtr);
}
@@ -2541,9 +2331,9 @@ Tcl_Close(interp, chan)
* Ensure that the last output buffer will be flushed.
*/
- if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
- chanPtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+ statePtr->flags |= BUFFER_READY;
}
/*
@@ -2564,7 +2354,7 @@ Tcl_Close(interp, chan)
* channel to be flushed and closed asynchronously.
*/
- chanPtr->flags |= CHANNEL_CLOSED;
+ statePtr->flags |= CHANNEL_CLOSED;
if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) {
return TCL_ERROR;
}
@@ -2596,10 +2386,17 @@ Tcl_ClearChannelHandlers (channel)
ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */
EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */
Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of real IO channel. */
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
NextChannelHandler *nhPtr;
- chanPtr = (Channel *) channel;
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = (Channel *) channel;
+ statePtr = chanPtr->state;
+ chanPtr = statePtr->topChanPtr;
/*
* Remove any references to channel handlers for this channel that
@@ -2607,8 +2404,8 @@ Tcl_ClearChannelHandlers (channel)
*/
for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
- nhPtr = nhPtr->nestedHandlerPtr) {
+ nhPtr != (NextChannelHandler *) NULL;
+ nhPtr = nhPtr->nestedHandlerPtr) {
if (nhPtr->nextHandlerPtr &&
(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
nhPtr->nextHandlerPtr = NULL;
@@ -2619,21 +2416,20 @@ Tcl_ClearChannelHandlers (channel)
* Remove all the channel handler records attached to the channel
* itself.
*/
-
- for (chPtr = chanPtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chNext) {
+
+ for (chPtr = statePtr->chPtr;
+ chPtr != (ChannelHandler *) NULL;
+ chPtr = chNext) {
chNext = chPtr->nextPtr;
ckfree((char *) chPtr);
}
- chanPtr->chPtr = (ChannelHandler *) NULL;
-
-
+ statePtr->chPtr = (ChannelHandler *) NULL;
+
/*
* Cancel any pending copy operation.
*/
- StopCopy(chanPtr->csPtr);
+ StopCopy(statePtr->csPtr);
/*
* Must set the interest mask now to 0, otherwise infinite loops
@@ -2642,20 +2438,20 @@ Tcl_ClearChannelHandlers (channel)
* has a background flush active.
*/
- chanPtr->interestMask = 0;
+ statePtr->interestMask = 0;
/*
* Remove any EventScript records for this channel.
*/
- for (ePtr = chanPtr->scriptRecordPtr;
- ePtr != (EventScriptRecord *) NULL;
- ePtr = eNextPtr) {
+ for (ePtr = statePtr->scriptRecordPtr;
+ ePtr != (EventScriptRecord *) NULL;
+ ePtr = eNextPtr) {
eNextPtr = ePtr->nextPtr;
Tcl_DecrRefCount(ePtr->scriptPtr);
ckfree((char *) ePtr);
}
- chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
}
/*
@@ -2686,12 +2482,19 @@ Tcl_Write(chan, src, srcLen)
int srcLen; /* Length of data in bytes, or < 0 for
* strlen(). */
{
+ /*
+ * Always use the topmost channel of the stack
+ */
Channel *chanPtr;
+ ChannelState *statePtr; /* state info for channel */
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+ statePtr = ((Channel *) chan)->state;
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
}
+
if (srcLen < 0) {
srcLen = strlen(src);
}
@@ -2699,6 +2502,61 @@ Tcl_Write(chan, src, srcLen)
}
/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_WriteRaw --
+ *
+ * Puts a sequence of bytes into an output buffer, may queue the
+ * buffer for output if it gets full, and also remembers whether the
+ * current buffer is ready e.g. if it contains a newline and we are in
+ * line buffering mode.
+ *
+ * Results:
+ * The number of bytes written or -1 in case of error. If -1,
+ * Tcl_GetErrno will return the error code.
+ *
+ * Side effects:
+ * May buffer up output and may cause output to be produced on the
+ * channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WriteRaw(chan, src, srcLen)
+ Tcl_Channel chan; /* The channel to buffer output for. */
+ char *src; /* Data to queue in output buffer. */
+ int srcLen; /* Length of data in bytes, or < 0 for
+ * strlen(). */
+{
+ Channel *chanPtr = ((Channel *) chan);
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ int errorCode, written;
+
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
+ return -1;
+ }
+
+ if (srcLen < 0) {
+ srcLen = strlen(src);
+ }
+
+ /*
+ * Go immediately to the driver, do all the error handling by ourselves.
+ * The code was stolen from 'FlushChannel'.
+ */
+
+ written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
+ src, srcLen, &errorCode);
+
+ if (written < 0) {
+ Tcl_SetErrno(errorCode);
+ }
+
+ return written;
+}
+
+/*
*---------------------------------------------------------------------------
*
* Tcl_WriteChars --
@@ -2727,16 +2585,22 @@ Tcl_WriteChars(chan, src, len)
int len; /* Length of string in bytes, or < 0 for
* strlen(). */
{
+ /*
+ * Always use the topmost channel of the stack
+ */
Channel *chanPtr;
+ ChannelState *statePtr; /* state info for channel */
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+ statePtr = ((Channel *) chan)->state;
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
}
if (len < 0) {
len = strlen(src);
}
- if (chanPtr->encoding == NULL) {
+ if (statePtr->encoding == NULL) {
/*
* Inefficient way to convert UTF-8 to byte-array, but the
* code parallels the way it is done for objects.
@@ -2784,15 +2648,21 @@ Tcl_WriteObj(chan, objPtr)
Tcl_Channel chan; /* The channel to buffer output for. */
Tcl_Obj *objPtr; /* The object to write. */
{
+ /*
+ * Always use the topmost channel of the stack
+ */
Channel *chanPtr;
+ ChannelState *statePtr; /* state info for channel */
char *src;
int srcLen;
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+ statePtr = ((Channel *) chan)->state;
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
}
- if (chanPtr->encoding == NULL) {
+ if (statePtr->encoding == NULL) {
src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
return WriteBytes(chanPtr, src, srcLen);
} else {
@@ -2828,6 +2698,7 @@ WriteBytes(chanPtr, src, srcLen)
CONST char *src; /* Bytes to write. */
int srcLen; /* Number of bytes to write. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
char *dst;
int dstLen, dstMax, sawLF, savedLF, total, toWrite;
@@ -2842,10 +2713,10 @@ WriteBytes(chanPtr, src, srcLen)
*/
while (srcLen + savedLF > 0) {
- bufPtr = chanPtr->curOutPtr;
+ bufPtr = statePtr->curOutPtr;
if (bufPtr == NULL) {
- bufPtr = AllocChannelBuffer(chanPtr->bufSize);
- chanPtr->curOutPtr = bufPtr;
+ bufPtr = AllocChannelBuffer(statePtr->bufSize);
+ statePtr->curOutPtr = bufPtr;
}
dst = bufPtr->buf + bufPtr->nextAdded;
dstMax = bufPtr->bufLength - bufPtr->nextAdded;
@@ -2867,7 +2738,7 @@ WriteBytes(chanPtr, src, srcLen)
dstLen--;
sawLF++;
}
- sawLF += TranslateOutputEOL(chanPtr, dst, src, &dstLen, &toWrite);
+ sawLF += TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite);
dstLen += savedLF;
savedLF = 0;
@@ -2915,6 +2786,7 @@ WriteChars(chanPtr, src, srcLen)
CONST char *src; /* UTF-8 string to write. */
int srcLen; /* Length of UTF-8 string in bytes. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
char *dst, *stage;
int saved, savedLF, sawLF, total, toWrite, flags;
@@ -2926,7 +2798,7 @@ WriteChars(chanPtr, src, srcLen)
sawLF = 0;
savedLF = 0;
saved = 0;
- encoding = chanPtr->encoding;
+ encoding = statePtr->encoding;
/*
* Loop over all UTF-8 characters in src, storing them in staging buffer
@@ -2934,8 +2806,8 @@ WriteChars(chanPtr, src, srcLen)
*/
while (srcLen + savedLF > 0) {
- stage = chanPtr->outputStage;
- stageMax = chanPtr->bufSize;
+ stage = statePtr->outputStage;
+ stageMax = statePtr->bufSize;
stageLen = stageMax;
toWrite = stageLen;
@@ -2955,7 +2827,7 @@ WriteChars(chanPtr, src, srcLen)
stageLen--;
sawLF++;
}
- sawLF += TranslateOutputEOL(chanPtr, stage, src, &stageLen, &toWrite);
+ sawLF += TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite);
stage -= savedLF;
stageLen += savedLF;
@@ -2968,7 +2840,7 @@ WriteChars(chanPtr, src, srcLen)
src += toWrite;
srcLen -= toWrite;
- flags = chanPtr->outputEncodingFlags;
+ flags = statePtr->outputEncodingFlags;
if (srcLen == 0) {
flags |= TCL_ENCODING_END;
}
@@ -2979,10 +2851,10 @@ WriteChars(chanPtr, src, srcLen)
*/
while (stageLen + saved > 0) {
- bufPtr = chanPtr->curOutPtr;
+ bufPtr = statePtr->curOutPtr;
if (bufPtr == NULL) {
- bufPtr = AllocChannelBuffer(chanPtr->bufSize);
- chanPtr->curOutPtr = bufPtr;
+ bufPtr = AllocChannelBuffer(statePtr->bufSize);
+ statePtr->curOutPtr = bufPtr;
}
dst = bufPtr->buf + bufPtr->nextAdded;
dstLen = bufPtr->bufLength - bufPtr->nextAdded;
@@ -3002,7 +2874,7 @@ WriteChars(chanPtr, src, srcLen)
}
Tcl_UtfToExternal(NULL, encoding, stage, stageLen, flags,
- &chanPtr->outputEncodingState, dst,
+ &statePtr->outputEncodingState, dst,
dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
if (stageRead + dstWrote == 0) {
/*
@@ -3086,8 +2958,8 @@ WriteChars(chanPtr, src, srcLen)
*/
static int
-TranslateOutputEOL(chanPtr, dst, src, dstLenPtr, srcLenPtr)
- Channel *chanPtr; /* Channel being read, for translation and
+TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
+ ChannelState *statePtr; /* Channel being read, for translation and
* buffering modes. */
char *dst; /* Output buffer filled with UTF-8 chars by
* applying appropriate EOL translation to
@@ -3106,7 +2978,7 @@ TranslateOutputEOL(chanPtr, dst, src, dstLenPtr, srcLenPtr)
newlineFound = 0;
srcLen = *srcLenPtr;
- switch (chanPtr->outputTranslation) {
+ switch (statePtr->outputTranslation) {
case TCL_TRANSLATE_LF: {
for (dstEnd = dst + srcLen; dst < dstEnd; ) {
if (*src == '\n') {
@@ -3198,6 +3070,7 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
int newlineFlag; /* Non-zero if a the channel buffer
* contains a newline. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
/*
* The current buffer is ready for output:
* 1. if it is full.
@@ -3205,18 +3078,18 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
* 3. if it contains any output and this channel is unbuffered.
*/
- if ((chanPtr->flags & BUFFER_READY) == 0) {
+ if ((statePtr->flags & BUFFER_READY) == 0) {
if (bufPtr->nextAdded == bufPtr->bufLength) {
- chanPtr->flags |= BUFFER_READY;
- } else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
+ statePtr->flags |= BUFFER_READY;
+ } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
if (newlineFlag != 0) {
- chanPtr->flags |= BUFFER_READY;
+ statePtr->flags |= BUFFER_READY;
}
- } else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
- chanPtr->flags |= BUFFER_READY;
+ } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
+ statePtr->flags |= BUFFER_READY;
}
}
- if (chanPtr->flags & BUFFER_READY) {
+ if (statePtr->flags & BUFFER_READY) {
if (FlushChannel(NULL, chanPtr, 0) != 0) {
return -1;
}
@@ -3297,22 +3170,28 @@ Tcl_GetsObj(chan, objPtr)
* object as UTF-8 characters. */
{
GetsState gs;
- Channel *chanPtr;
- int inEofChar, skip, copiedTotal;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
+ int inEofChar, skip, copiedTotal;
Tcl_Encoding encoding;
char *dst, *dstEnd, *eol, *eof;
Tcl_EncodingState oldState;
int oldLength, oldFlags, oldRemoved;
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
copiedTotal = -1;
goto done;
}
- bufPtr = chanPtr->inQueueHead;
- encoding = chanPtr->encoding;
+ bufPtr = statePtr->inQueueHead;
+ encoding = statePtr->encoding;
/*
* Preserved so we can restore the channel's state in case we don't
@@ -3320,8 +3199,8 @@ Tcl_GetsObj(chan, objPtr)
*/
Tcl_GetStringFromObj(objPtr, &oldLength);
- oldFlags = chanPtr->inputEncodingFlags;
- oldState = chanPtr->inputEncodingState;
+ oldFlags = statePtr->inputEncodingFlags;
+ oldState = statePtr->inputEncodingState;
oldRemoved = BUFFER_PADDING;
if (bufPtr != NULL) {
oldRemoved = bufPtr->nextRemoved;
@@ -3357,7 +3236,7 @@ Tcl_GetsObj(chan, objPtr)
skip = 0;
eof = NULL;
- inEofChar = chanPtr->inEofChar;
+ inEofChar = statePtr->inEofChar;
while (1) {
if (dst >= dstEnd) {
@@ -3388,7 +3267,7 @@ Tcl_GetsObj(chan, objPtr)
*/
eol = dst;
- switch (chanPtr->inputTranslation) {
+ switch (statePtr->inputTranslation) {
case TCL_TRANSLATE_LF: {
for (eol = dst; eol < dstEnd; eol++) {
if (*eol == '\n') {
@@ -3437,8 +3316,8 @@ Tcl_GetsObj(chan, objPtr)
}
case TCL_TRANSLATE_AUTO: {
skip = 1;
- if (chanPtr->flags & INPUT_SAW_CR) {
- chanPtr->flags &= ~INPUT_SAW_CR;
+ if (statePtr->flags & INPUT_SAW_CR) {
+ statePtr->flags &= ~INPUT_SAW_CR;
if (*eol == '\n') {
/*
* Skip the raw bytes that make up the '\n'.
@@ -3450,7 +3329,7 @@ Tcl_GetsObj(chan, objPtr)
bufPtr = gs.bufPtr;
Tcl_ExternalToUtf(NULL, gs.encoding,
bufPtr->buf + bufPtr->nextRemoved,
- gs.rawRead, chanPtr->inputEncodingFlags,
+ gs.rawRead, statePtr->inputEncodingFlags,
&gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead,
NULL, NULL);
bufPtr->nextRemoved += rawRead;
@@ -3478,7 +3357,7 @@ Tcl_GetsObj(chan, objPtr)
eol = objPtr->bytes + offset;
if (eol >= dstEnd) {
eol--;
- chanPtr->flags |= INPUT_SAW_CR;
+ statePtr->flags |= INPUT_SAW_CR;
goto goteol;
}
}
@@ -3501,10 +3380,10 @@ Tcl_GetsObj(chan, objPtr)
*/
dstEnd = eof;
- chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
- chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+ statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
}
- if (chanPtr->flags & CHANNEL_EOF) {
+ if (statePtr->flags & CHANNEL_EOF) {
skip = 0;
eol = dstEnd;
if (eol == objPtr->bytes) {
@@ -3533,10 +3412,10 @@ Tcl_GetsObj(chan, objPtr)
goteol:
bufPtr = gs.bufPtr;
- chanPtr->inputEncodingState = gs.state;
+ statePtr->inputEncodingState = gs.state;
Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved,
- gs.rawRead, chanPtr->inputEncodingFlags,
- &chanPtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX,
+ gs.rawRead, statePtr->inputEncodingFlags,
+ &statePtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX,
&gs.rawRead, NULL, &gs.charsWrote);
bufPtr->nextRemoved += gs.rawRead;
@@ -3546,7 +3425,7 @@ Tcl_GetsObj(chan, objPtr)
Tcl_SetObjLength(objPtr, eol - objPtr->bytes);
CommonGetsCleanup(chanPtr, encoding);
- chanPtr->flags &= ~CHANNEL_BLOCKED;
+ statePtr->flags &= ~CHANNEL_BLOCKED;
copiedTotal = gs.totalChars + gs.charsWrote - skip;
goto done;
@@ -3557,7 +3436,7 @@ Tcl_GetsObj(chan, objPtr)
*/
restore:
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
bufPtr->nextRemoved = oldRemoved;
for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
@@ -3565,8 +3444,8 @@ Tcl_GetsObj(chan, objPtr)
}
CommonGetsCleanup(chanPtr, encoding);
- chanPtr->inputEncodingState = oldState;
- chanPtr->inputEncodingFlags = oldFlags;
+ statePtr->inputEncodingState = oldState;
+ statePtr->inputEncodingFlags = oldFlags;
Tcl_SetObjLength(objPtr, oldLength);
/*
@@ -3580,7 +3459,7 @@ Tcl_GetsObj(chan, objPtr)
* though a read would be able to consume the buffered data.
*/
- chanPtr->flags |= CHANNEL_NEED_MORE_DATA;
+ statePtr->flags |= CHANNEL_NEED_MORE_DATA;
copiedTotal = -1;
done:
@@ -3622,6 +3501,7 @@ FilterInputBytes(chanPtr, gsPtr)
Channel *chanPtr; /* Channel to read. */
GetsState *gsPtr; /* Current state of gets operation. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
char *raw, *rawStart, *rawEnd;
char *dst;
@@ -3658,20 +3538,20 @@ FilterInputBytes(chanPtr, gsPtr)
*/
read:
- if (chanPtr->flags & CHANNEL_BLOCKED) {
- if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
gsPtr->charsWrote = 0;
gsPtr->rawRead = 0;
return -1;
}
- chanPtr->flags &= ~CHANNEL_BLOCKED;
+ statePtr->flags &= ~CHANNEL_BLOCKED;
}
if (GetInput(chanPtr) != 0) {
gsPtr->charsWrote = 0;
gsPtr->rawRead = 0;
return -1;
}
- bufPtr = chanPtr->inQueueTail;
+ bufPtr = statePtr->inQueueTail;
gsPtr->bufPtr = bufPtr;
}
@@ -3705,9 +3585,9 @@ FilterInputBytes(chanPtr, gsPtr)
dst = objPtr->bytes + offset;
*gsPtr->dstPtr = dst;
}
- gsPtr->state = chanPtr->inputEncodingState;
+ gsPtr->state = statePtr->inputEncodingState;
result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen,
- chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
dst, spaceLeft, &gsPtr->rawRead, &gsPtr->bytesWrote,
&gsPtr->charsWrote);
if (result == TCL_CONVERT_MULTIBYTE) {
@@ -3728,13 +3608,13 @@ FilterInputBytes(chanPtr, gsPtr)
* returning those UTF-8 characters because a EOL might be
* present in them.
*/
- } else if (chanPtr->flags & CHANNEL_EOF) {
+ } else if (statePtr->flags & CHANNEL_EOF) {
/*
* There was a partial character followed by EOF on the
* device. Fall through, returning that nothing was found.
*/
- bufPtr->nextRemoved = bufPtr->nextAdded;
+ bufPtr->nextRemoved = bufPtr->nextAdded;
} else {
/*
* There are no more cached raw bytes left. See if we can
@@ -3745,9 +3625,9 @@ FilterInputBytes(chanPtr, gsPtr)
}
} else {
if (nextPtr == NULL) {
- nextPtr = AllocChannelBuffer(chanPtr->bufSize);
+ nextPtr = AllocChannelBuffer(statePtr->bufSize);
bufPtr->nextPtr = nextPtr;
- chanPtr->inQueueTail = nextPtr;
+ statePtr->inQueueTail = nextPtr;
}
extra = rawLen - gsPtr->rawRead;
memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
@@ -3790,6 +3670,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
* of UTF-8 characters. */
GetsState *gsPtr; /* Current state of gets operation. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
Tcl_DriverBlockModeProc *blockModeProc;
int bytesLeft;
@@ -3815,8 +3696,8 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
goto cleanup;
}
- if ((chanPtr->flags & CHANNEL_NONBLOCKING) == 0) {
- blockModeProc = chanPtr->typePtr->blockModeProc;
+ if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) {
+ blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
if (blockModeProc == NULL) {
/*
* Don't peek ahead if cannot set non-blocking mode.
@@ -3824,7 +3705,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
goto cleanup;
}
- (*blockModeProc)(chanPtr->instanceData, TCL_MODE_NONBLOCKING);
+ StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
}
}
}
@@ -3832,7 +3713,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
*dstEndPtr = *gsPtr->dstPtr + gsPtr->bytesWrote;
}
if (blockModeProc != NULL) {
- (*blockModeProc)(chanPtr->instanceData, TCL_MODE_BLOCKING);
+ StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
}
return;
@@ -3866,19 +3747,20 @@ CommonGetsCleanup(chanPtr, encoding)
Channel *chanPtr;
Tcl_Encoding encoding;
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr, *nextPtr;
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
for ( ; bufPtr != NULL; bufPtr = nextPtr) {
nextPtr = bufPtr->nextPtr;
if (bufPtr->nextRemoved < bufPtr->nextAdded) {
break;
}
- RecycleBuffer(chanPtr, bufPtr, 0);
+ RecycleBuffer(statePtr, bufPtr, 0);
}
- chanPtr->inQueueHead = bufPtr;
+ statePtr->inQueueHead = bufPtr;
if (bufPtr == NULL) {
- chanPtr->inQueueTail = NULL;
+ statePtr->inQueueTail = NULL;
} else {
/*
* If any multi-byte characters were split across channel buffer
@@ -3904,7 +3786,7 @@ CommonGetsCleanup(chanPtr, encoding)
bufPtr = nextPtr;
}
}
- if (chanPtr->encoding == NULL) {
+ if (statePtr->encoding == NULL) {
Tcl_FreeEncoding(encoding);
}
}
@@ -3937,10 +3819,16 @@ Tcl_Read(chan, dst, bytesToRead)
char *dst; /* Where to store input read. */
int bytesToRead; /* Maximum number of bytes to read. */
{
- Channel *chanPtr;
-
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
+
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
return -1;
}
@@ -3948,6 +3836,127 @@ 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.
+ *
+ * No encoding conversions are applied to the bytes being read.
+ *
+ * Results:
+ * The number of bytes read, or -1 on error. Use Tcl_GetErrno()
+ * to retrieve the error code for the error that occurred.
+ *
+ * Side effects:
+ * May cause input to be buffered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ReadRaw(chan, bufPtr, bytesToRead)
+ Tcl_Channel chan; /* The channel from which to read. */
+ char *bufPtr; /* Where to store input read. */
+ int bytesToRead; /* Maximum number of bytes to read. */
+{
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ int nread, result;
+ int copied, copiedNow;
+
+ /*
+ * The check below does too much because it will reject a call to this
+ * function with a channel which is part of an 'fcopy'. But we have to
+ * allow this here or else the chaining in the transformation drivers
+ * will fail with 'file busy' error instead of retrieving and
+ * transforming the data to copy.
+ *
+ * We let the check procedure now believe that there is no fcopy in
+ * progress. A better solution than this might be an additional flag
+ * argument to switch off specific checks.
+ */
+
+ if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) {
+ return -1;
+ }
+
+ /*
+ * Check for information in the push-back buffers. If there is
+ * some, use it. Go to the driver only if there is none (anymore)
+ * and the caller requests more bytes.
+ */
+
+ for (copied = 0; copied < bytesToRead; copied += copiedNow) {
+ copiedNow = CopyBuffer(chanPtr, bufPtr + copied,
+ bytesToRead - copied);
+ if (copiedNow == 0) {
+ if (statePtr->flags & CHANNEL_EOF) {
+ goto done;
+ }
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
+ goto done;
+ }
+ statePtr->flags &= (~(CHANNEL_BLOCKED));
+ }
+
+ /*
+ * Now go to the driver to get as much as is possible to
+ * fill the remaining request. Do all the error handling
+ * by ourselves. The code was stolen from 'GetInput' and
+ * slightly adapted (different return value here).
+ *
+ * The case of 'bytesToRead == 0' at this point cannot happen.
+ */
+
+ nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+ bufPtr + copied, bytesToRead - copied, &result);
+ if (nread > 0) {
+ /*
+ * If we get a short read, signal up that we may be
+ * BLOCKED. We should avoid calling the driver because
+ * on some platforms we will block in the low level
+ * reading code even though the channel is set into
+ * nonblocking mode.
+ */
+
+ if (nread < (bytesToRead - copied)) {
+ statePtr->flags |= CHANNEL_BLOCKED;
+ }
+ } else if (nread == 0) {
+ statePtr->flags |= CHANNEL_EOF;
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+ } else if (nread < 0) {
+ if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
+ if (copied > 0) {
+ /*
+ * Information that was copied earlier has precedence
+ * over EAGAIN/WOULDBLOCK handling.
+ */
+ return copied;
+ }
+
+ statePtr->flags |= CHANNEL_BLOCKED;
+ result = EAGAIN;
+ }
+
+ Tcl_SetErrno(result);
+ return -1;
+ }
+
+ return copied + nread;
+ }
+ }
+
+done:
+ return copied;
+}
+
+/*
*---------------------------------------------------------------------------
*
* Tcl_ReadChars --
@@ -3982,19 +3991,25 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
* of the object. */
{
- Channel *chanPtr;
- int offset, factor, copied, copiedNow, result;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
+ int offset, factor, copied, copiedNow, result;
Tcl_Encoding encoding;
#define UTF_EXPANSION_FACTOR 1024
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
copied = -1;
goto done;
}
- encoding = chanPtr->encoding;
+ encoding = statePtr->encoding;
factor = UTF_EXPANSION_FACTOR;
if (appendFlag == 0) {
@@ -4014,11 +4029,11 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
for (copied = 0; (unsigned) toRead > 0; ) {
copiedNow = -1;
- if (chanPtr->inQueueHead != NULL) {
+ if (statePtr->inQueueHead != NULL) {
if (encoding == NULL) {
- copiedNow = ReadBytes(chanPtr, objPtr, toRead, &offset);
+ copiedNow = ReadBytes(statePtr, objPtr, toRead, &offset);
} else {
- copiedNow = ReadChars(chanPtr, objPtr, toRead, &offset,
+ copiedNow = ReadChars(statePtr, objPtr, toRead, &offset,
&factor);
}
@@ -4026,27 +4041,27 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
* If the current buffer is empty recycle it.
*/
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
ChannelBuffer *nextPtr;
nextPtr = bufPtr->nextPtr;
- RecycleBuffer(chanPtr, bufPtr, 0);
- chanPtr->inQueueHead = nextPtr;
+ RecycleBuffer(statePtr, bufPtr, 0);
+ statePtr->inQueueHead = nextPtr;
if (nextPtr == NULL) {
- chanPtr->inQueueTail = nextPtr;
+ statePtr->inQueueTail = nextPtr;
}
}
}
if (copiedNow < 0) {
- if (chanPtr->flags & CHANNEL_EOF) {
+ if (statePtr->flags & CHANNEL_EOF) {
break;
}
- if (chanPtr->flags & CHANNEL_BLOCKED) {
- if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
break;
}
- chanPtr->flags &= ~CHANNEL_BLOCKED;
+ statePtr->flags &= ~CHANNEL_BLOCKED;
}
result = GetInput(chanPtr);
if (result != 0) {
@@ -4061,7 +4076,7 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
toRead -= copiedNow;
}
}
- chanPtr->flags &= ~CHANNEL_BLOCKED;
+ statePtr->flags &= ~CHANNEL_BLOCKED;
if (encoding == NULL) {
Tcl_SetByteArrayLength(objPtr, offset);
} else {
@@ -4104,8 +4119,8 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
*/
static int
-ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
- Channel *chanPtr; /* The channel to read. */
+ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
+ ChannelState *statePtr; /* State of the channel to read. */
int bytesToRead; /* Maximum number of characters to store,
* or < 0 to get all available characters.
* Characters are obtained from the first
@@ -4130,7 +4145,7 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
offset = *offsetPtr;
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
src = bufPtr->buf + bufPtr->nextRemoved;
srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
@@ -4155,8 +4170,8 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
}
dst += offset;
- if (chanPtr->flags & INPUT_NEED_NL) {
- chanPtr->flags &= ~INPUT_NEED_NL;
+ if (statePtr->flags & INPUT_NEED_NL) {
+ statePtr->flags &= ~INPUT_NEED_NL;
if ((srcLen == 0) || (*src != '\n')) {
*dst = '\r';
*offsetPtr += 1;
@@ -4170,7 +4185,7 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
srcRead = srcLen;
dstWrote = toRead;
- if (TranslateInputEOL(chanPtr, dst, src, &dstWrote, &srcRead) != 0) {
+ if (TranslateInputEOL(statePtr, dst, src, &dstWrote, &srcRead) != 0) {
if (dstWrote == 0) {
return -1;
}
@@ -4208,8 +4223,8 @@ ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr)
*/
static int
-ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
- Channel *chanPtr; /* The channel to read. */
+ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
+ ChannelState *statePtr; /* State of channel to read. */
int charsToRead; /* Maximum number of characters to store,
* or -1 to get all available characters.
* Characters are obtained from the first
@@ -4241,7 +4256,7 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
factor = *factorPtr;
offset = *offsetPtr;
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
src = bufPtr->buf + bufPtr->nextRemoved;
srcLen = bufPtr->nextAdded - bufPtr->nextRemoved;
@@ -4286,21 +4301,21 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
}
dst = objPtr->bytes + offset;
- oldState = chanPtr->inputEncodingState;
- if (chanPtr->flags & INPUT_NEED_NL) {
+ oldState = statePtr->inputEncodingState;
+ if (statePtr->flags & INPUT_NEED_NL) {
/*
* We want a '\n' because the last character we saw was '\r'.
*/
-
- chanPtr->flags &= ~INPUT_NEED_NL;
- Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
- chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+
+ statePtr->flags &= ~INPUT_NEED_NL;
+ Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars);
if ((dstWrote > 0) && (*dst == '\n')) {
/*
* The next char was a '\n'. Consume it and produce a '\n'.
*/
-
+
bufPtr->nextRemoved += srcRead;
} else {
/*
@@ -4309,13 +4324,13 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
*dst = '\r';
}
- chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+ statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
*offsetPtr += 1;
return 1;
}
- Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
- chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, dst,
+ Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst,
dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
if (srcRead == 0) {
/*
@@ -4334,19 +4349,19 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
* file event can be delivered.
*/
- chanPtr->flags |= CHANNEL_NEED_MORE_DATA;
+ statePtr->flags |= CHANNEL_NEED_MORE_DATA;
return -1;
}
nextPtr->nextRemoved -= srcLen;
memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src,
(size_t) srcLen);
- RecycleBuffer(chanPtr, bufPtr, 0);
- chanPtr->inQueueHead = nextPtr;
- return ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr);
+ RecycleBuffer(statePtr, bufPtr, 0);
+ statePtr->inQueueHead = nextPtr;
+ return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
}
dstRead = dstWrote;
- if (TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead) != 0) {
+ if (TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead) != 0) {
/*
* Hit EOF char. How many bytes of src correspond to where the
* EOF was located in dst?
@@ -4355,11 +4370,11 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
if (dstWrote == 0) {
return -1;
}
- chanPtr->inputEncodingState = oldState;
- Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
- chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+ statePtr->inputEncodingState = oldState;
+ Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
dst, dstRead + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
- TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead);
+ TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
}
/*
@@ -4378,15 +4393,15 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
char *eof;
eof = Tcl_UtfAtIndex(dst, toRead);
- chanPtr->inputEncodingState = oldState;
- Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen,
- chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState,
+ statePtr->inputEncodingState = oldState;
+ Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
+ statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
dst, eof - dst + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
dstRead = dstWrote;
- TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead);
+ TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
numChars -= (dstRead - dstWrote);
}
- chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+ statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
bufPtr->nextRemoved += srcRead;
if (dstWrote > srcRead + 1) {
@@ -4415,8 +4430,8 @@ ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr)
*/
static int
-TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
- Channel *chanPtr; /* Channel being read, for EOL translation
+TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
+ ChannelState *statePtr; /* Channel being read, for EOL translation
* and EOF character. */
char *dstStart; /* Output buffer filled with chars by
* applying appropriate EOL translation to
@@ -4436,7 +4451,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
dstLen = *dstLenPtr;
eof = NULL;
- inEofChar = chanPtr->inEofChar;
+ inEofChar = statePtr->inEofChar;
if (inEofChar != '\0') {
/*
* Find EOF in translated buffer then compress out the EOL. The
@@ -4460,7 +4475,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
}
}
}
- switch (chanPtr->inputTranslation) {
+ switch (statePtr->inputTranslation) {
case TCL_TRANSLATE_LF: {
if (dstStart != srcStart) {
memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
@@ -4496,7 +4511,7 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
if (*src == '\r') {
src++;
if (src >= srcMax) {
- chanPtr->flags |= INPUT_NEED_NL;
+ statePtr->flags |= INPUT_NEED_NL;
} else if (*src == '\n') {
*dst++ = *src++;
} else {
@@ -4519,17 +4534,17 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
srcEnd = srcStart + dstLen;
srcMax = srcStart + *srcLenPtr;
- if ((chanPtr->flags & INPUT_SAW_CR) && (src < srcMax)) {
+ if ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) {
if (*src == '\n') {
src++;
}
- chanPtr->flags &= ~INPUT_SAW_CR;
+ statePtr->flags &= ~INPUT_SAW_CR;
}
for ( ; src < srcEnd; ) {
if (*src == '\r') {
src++;
if (src >= srcMax) {
- chanPtr->flags |= INPUT_SAW_CR;
+ statePtr->flags |= INPUT_SAW_CR;
} else if (*src == '\n') {
if (srcEnd < srcMax) {
srcEnd++;
@@ -4558,9 +4573,9 @@ TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
* EOF character in the output string.
*/
- chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
- chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
- chanPtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
+ statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+ statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
return 1;
}
@@ -4594,21 +4609,29 @@ Tcl_Ungets(chan, str, len, atEnd)
* add at head of queue. */
{
Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of actual channel. */
ChannelBuffer *bufPtr; /* Buffer to contain the data. */
int i, flags;
chanPtr = (Channel *) chan;
-
+ statePtr = chanPtr->state;
+
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
/*
* CheckChannelErrors clears too many flag bits in this one case.
*/
- flags = chanPtr->flags;
- if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) {
+ flags = statePtr->flags;
+ if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
len = -1;
goto done;
}
- chanPtr->flags = flags;
+ statePtr->flags = flags;
/*
* If we have encountered a sticky EOF, just punt without storing.
@@ -4618,10 +4641,10 @@ Tcl_Ungets(chan, str, len, atEnd)
* in each operation.
*/
- if (chanPtr->flags & CHANNEL_STICKY_EOF) {
+ if (statePtr->flags & CHANNEL_STICKY_EOF) {
goto done;
}
- chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
+ statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
bufPtr = AllocChannelBuffer(len);
for (i = 0; i < len; i++) {
@@ -4629,17 +4652,17 @@ Tcl_Ungets(chan, str, len, atEnd)
}
bufPtr->nextAdded += len;
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+ if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
bufPtr->nextPtr = (ChannelBuffer *) NULL;
- chanPtr->inQueueHead = bufPtr;
- chanPtr->inQueueTail = bufPtr;
+ statePtr->inQueueHead = bufPtr;
+ statePtr->inQueueTail = bufPtr;
} else if (atEnd) {
bufPtr->nextPtr = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail->nextPtr = bufPtr;
- chanPtr->inQueueTail = bufPtr;
+ statePtr->inQueueTail->nextPtr = bufPtr;
+ statePtr->inQueueTail = bufPtr;
} else {
- bufPtr->nextPtr = chanPtr->inQueueHead;
- chanPtr->inQueueHead = bufPtr;
+ bufPtr->nextPtr = statePtr->inQueueHead;
+ statePtr->inQueueHead = bufPtr;
}
done:
@@ -4673,10 +4696,16 @@ Tcl_Flush(chan)
Tcl_Channel chan; /* The Channel to flush. */
{
int result; /* Of calling FlushChannel. */
- Channel *chanPtr; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ ChannelState *statePtr = chanPtr->state; /* State of actual channel. */
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) {
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
return -1;
}
@@ -4684,14 +4713,14 @@ Tcl_Flush(chan)
* Force current output buffer to be output also.
*/
- if ((chanPtr->curOutPtr != NULL)
- && (chanPtr->curOutPtr->nextAdded > 0)) {
- chanPtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != NULL)
+ && (statePtr->curOutPtr->nextAdded > 0)) {
+ statePtr->flags |= BUFFER_READY;
}
-
+
result = FlushChannel(NULL, chanPtr, 0);
if (result != 0) {
- return TCL_ERROR;
+ return TCL_ERROR;
}
return TCL_OK;
@@ -4716,32 +4745,32 @@ Tcl_Flush(chan)
*/
static void
-DiscardInputQueued(chanPtr, discardSavedBuffers)
- Channel *chanPtr; /* Channel on which to discard
- * the queued input. */
+DiscardInputQueued(statePtr, discardSavedBuffers)
+ ChannelState *statePtr; /* Channel on which to discard
+ * the queued input. */
int discardSavedBuffers; /* If non-zero, discard all buffers including
- * last one. */
+ * last one. */
{
ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
- bufPtr = chanPtr->inQueueHead;
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ bufPtr = statePtr->inQueueHead;
+ statePtr->inQueueHead = (ChannelBuffer *) NULL;
+ statePtr->inQueueTail = (ChannelBuffer *) NULL;
for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
- nxtPtr = bufPtr->nextPtr;
- RecycleBuffer(chanPtr, bufPtr, discardSavedBuffers);
+ nxtPtr = bufPtr->nextPtr;
+ RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
}
/*
* If discardSavedBuffers is nonzero, must also discard any previously
* saved buffer in the saveInBufPtr field.
*/
-
+
if (discardSavedBuffers) {
- if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
- ckfree((char *) chanPtr->saveInBufPtr);
- chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
- }
+ if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) {
+ ckfree((char *) statePtr->saveInBufPtr);
+ statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
+ }
}
}
@@ -4770,6 +4799,7 @@ GetInput(chanPtr)
int result; /* Of calling driver. */
int nread; /* How much was read from channel? */
ChannelBuffer *bufPtr; /* New buffer to add to input queue. */
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
/*
* Prevent reading from a dead channel -- a channel that has been closed
@@ -4778,34 +4808,62 @@ GetInput(chanPtr)
* interpreter.
*/
- if (CheckForDeadChannel(NULL, chanPtr)) {
+ if (CheckForDeadChannel(NULL, statePtr)) {
return EINVAL;
}
/*
+ * First check for more buffers in the pushback area of the
+ * topmost channel in the stack and use them. They can be the
+ * result of a transformation which went away without reading all
+ * the information placed in the area when it was stacked.
+ *
+ * Two possibilities for the state: No buffers in it, or a single
+ * empty buffer. In the latter case we can recycle it now.
+ */
+
+ if (chanPtr->inQueueHead != (ChannelBuffer*) NULL) {
+ if (statePtr->inQueueHead != (ChannelBuffer*) NULL) {
+ RecycleBuffer(statePtr, statePtr->inQueueHead, 0);
+ statePtr->inQueueHead = (ChannelBuffer*) NULL;
+ }
+
+ statePtr->inQueueHead = chanPtr->inQueueHead;
+ statePtr->inQueueTail = chanPtr->inQueueTail;
+ chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+ chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ return 0;
+ }
+
+ /*
+ * Nothing in the pushback area, fall back to the usual handling
+ * (driver, etc.)
+ */
+
+ /*
* See if we can fill an existing buffer. If we can, read only
* as much as will fit in it. Otherwise allocate a new buffer,
* add it to the input queue and attempt to fill it to the max.
*/
- bufPtr = chanPtr->inQueueTail;
+ bufPtr = statePtr->inQueueTail;
if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) {
toRead = bufPtr->bufLength - bufPtr->nextAdded;
} else {
- bufPtr = chanPtr->saveInBufPtr;
- chanPtr->saveInBufPtr = NULL;
+ bufPtr = statePtr->saveInBufPtr;
+ statePtr->saveInBufPtr = NULL;
if (bufPtr == NULL) {
- bufPtr = AllocChannelBuffer(chanPtr->bufSize);
+ bufPtr = AllocChannelBuffer(statePtr->bufSize);
}
bufPtr->nextPtr = (ChannelBuffer *) NULL;
- toRead = chanPtr->bufSize;
- if (chanPtr->inQueueTail == NULL) {
- chanPtr->inQueueHead = bufPtr;
+ toRead = statePtr->bufSize;
+ if (statePtr->inQueueTail == NULL) {
+ statePtr->inQueueHead = bufPtr;
} else {
- chanPtr->inQueueTail->nextPtr = bufPtr;
+ statePtr->inQueueTail->nextPtr = bufPtr;
}
- chanPtr->inQueueTail = bufPtr;
+ statePtr->inQueueTail = bufPtr;
}
/*
@@ -4813,11 +4871,11 @@ GetInput(chanPtr)
* platforms it is impossible to read from a device after EOF.
*/
- if (chanPtr->flags & CHANNEL_EOF) {
+ if (statePtr->flags & CHANNEL_EOF) {
return 0;
}
- nread = (*chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+ nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
bufPtr->buf + bufPtr->nextAdded, toRead, &result);
if (nread > 0) {
@@ -4831,14 +4889,14 @@ GetInput(chanPtr)
*/
if (nread < toRead) {
- chanPtr->flags |= CHANNEL_BLOCKED;
+ statePtr->flags |= CHANNEL_BLOCKED;
}
} else if (nread == 0) {
- chanPtr->flags |= CHANNEL_EOF;
- chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+ statePtr->flags |= CHANNEL_EOF;
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
} else if (nread < 0) {
if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
- chanPtr->flags |= CHANNEL_BLOCKED;
+ statePtr->flags |= CHANNEL_BLOCKED;
result = EAGAIN;
}
Tcl_SetErrno(result);
@@ -4871,7 +4929,8 @@ Tcl_Seek(chan, offset, mode)
int offset; /* Offset to seek to. */
int mode; /* Relative to which location to seek? */
{
- Channel *chanPtr; /* The real IO channel. */
+ Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
int inputBuffered, outputBuffered;
int result; /* Of device driver operations. */
@@ -4880,8 +4939,7 @@ Tcl_Seek(chan, offset, mode)
* seek operation? If so, must restore to
* nonblocking mode after the seek. */
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
return -1;
}
@@ -4892,7 +4950,13 @@ Tcl_Seek(chan, offset, mode)
* registered in an interpreter.
*/
- if (CheckForDeadChannel(NULL,chanPtr)) return -1;
+ if (CheckForDeadChannel(NULL, statePtr)) return -1;
+
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
/*
* Disallow seek on channels whose type does not have a seek procedure
@@ -4909,21 +4973,32 @@ Tcl_Seek(chan, offset, mode)
* output is buffered, cannot compute the current position.
*/
- for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+ for (bufPtr = statePtr->inQueueHead, inputBuffered = 0;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
- for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+
+ /*
+ * Don't forget the bytes in the topmost pushback area.
+ */
+
+ for (bufPtr = statePtr->topChanPtr->inQueueHead;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
+ inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ }
+
+ for (bufPtr = statePtr->outQueueHead, outputBuffered = 0;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
- if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
- chanPtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+ statePtr->flags |= BUFFER_READY;
outputBuffered +=
- (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
+ (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
}
if ((inputBuffered != 0) && (outputBuffered != 0)) {
@@ -4945,14 +5020,14 @@ Tcl_Seek(chan, offset, mode)
* the seek.
*/
- DiscardInputQueued(chanPtr, 0);
+ DiscardInputQueued(statePtr, 0);
/*
* Reset EOF and BLOCKED flags. We invalidate them by moving the
* access point. Also clear CR related flags.
*/
- chanPtr->flags &=
+ statePtr->flags &=
(~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR));
/*
@@ -4963,20 +5038,15 @@ Tcl_Seek(chan, offset, mode)
*/
wasAsync = 0;
- if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
wasAsync = 1;
- result = 0;
- if (chanPtr->typePtr->blockModeProc != NULL) {
- result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
- TCL_MODE_BLOCKING);
- }
- if (result != 0) {
- Tcl_SetErrno(result);
- return -1;
- }
- chanPtr->flags &= (~(CHANNEL_NONBLOCKING));
- if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
- chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
+ result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
+ if (result != 0) {
+ return -1;
+ }
+ statePtr->flags &= (~(CHANNEL_NONBLOCKING));
+ if (statePtr->flags & BG_FLUSH_SCHEDULED) {
+ statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
}
}
@@ -5012,16 +5082,11 @@ Tcl_Seek(chan, offset, mode)
*/
if (wasAsync) {
- chanPtr->flags |= CHANNEL_NONBLOCKING;
- result = 0;
- if (chanPtr->typePtr->blockModeProc != NULL) {
- result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
- TCL_MODE_NONBLOCKING);
- }
- if (result != 0) {
- Tcl_SetErrno(result);
- return -1;
- }
+ statePtr->flags |= CHANNEL_NONBLOCKING;
+ result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
+ if (result != 0) {
+ return -1;
+ }
}
return curPos;
@@ -5050,14 +5115,14 @@ int
Tcl_Tell(chan)
Tcl_Channel chan; /* The channel to return pos for. */
{
- Channel *chanPtr; /* The actual channel to tell on. */
+ Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
int inputBuffered, outputBuffered;
int result; /* Of calling device driver. */
int curPos; /* Position on device. */
- chanPtr = (Channel *) chan;
- if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+ if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
return -1;
}
@@ -5068,11 +5133,17 @@ Tcl_Tell(chan)
* registered in an interpreter.
*/
- if (CheckForDeadChannel(NULL,chanPtr)) {
+ if (CheckForDeadChannel(NULL, statePtr)) {
return -1;
}
/*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
+ /*
* Disallow tell on channels whose type does not have a seek procedure
* defined. This means that the channel does not support seeking.
*/
@@ -5087,21 +5158,21 @@ Tcl_Tell(chan)
* output is buffered, cannot compute the current position.
*/
- for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+ for (bufPtr = statePtr->inQueueHead, inputBuffered = 0;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
- for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+ for (bufPtr = statePtr->outQueueHead, outputBuffered = 0;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
- if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
- chanPtr->flags |= BUFFER_READY;
+ if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+ statePtr->flags |= BUFFER_READY;
outputBuffered +=
- (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
+ (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
}
if ((inputBuffered != 0) && (outputBuffered != 0)) {
@@ -5145,18 +5216,33 @@ Tcl_Tell(chan)
*/
static int
-CheckChannelErrors(chanPtr, direction)
- Channel *chanPtr; /* Channel to check. */
- int direction; /* Test if channel supports desired operation:
- * TCL_READABLE, TCL_WRITABLE. */
+CheckChannelErrors(statePtr, flags)
+ ChannelState *statePtr; /* Channel to check. */
+ int flags; /* Test if channel supports desired operation:
+ * TCL_READABLE, TCL_WRITABLE. Also indicates
+ * Raw read or write for special close
+ * processing*/
{
+ int direction = flags & (TCL_READABLE|TCL_WRITABLE);
+
/*
* Check for unreported error.
*/
- if (chanPtr->unreportedError != 0) {
- Tcl_SetErrno(chanPtr->unreportedError);
- chanPtr->unreportedError = 0;
+ if (statePtr->unreportedError != 0) {
+ Tcl_SetErrno(statePtr->unreportedError);
+ statePtr->unreportedError = 0;
+ return -1;
+ }
+
+ /*
+ * Only the raw read and write operations are allowed during close
+ * in order to drain data from stacked channels.
+ */
+
+ if ((statePtr->flags & CHANNEL_CLOSED) &&
+ ((flags & CHANNEL_RAW_MODE) == 0)) {
+ Tcl_SetErrno(EACCES);
return -1;
}
@@ -5164,16 +5250,20 @@ CheckChannelErrors(chanPtr, direction)
* Fail if the channel is not opened for desired operation.
*/
- if ((chanPtr->flags & direction) == 0) {
+ if ((statePtr->flags & direction) == 0) {
Tcl_SetErrno(EACCES);
return -1;
}
/*
* Fail if the channel is in the middle of a background copy.
+ *
+ * Don't do this tests for raw channels here or else the chaining in the
+ * transformation drivers will fail with 'file busy' error instead of
+ * retrieving and transforming the data to copy.
*/
- if (chanPtr->csPtr != NULL) {
+ if ((statePtr->csPtr != NULL) && ((flags & CHANNEL_RAW_MODE) == 0)) {
Tcl_SetErrno(EBUSY);
return -1;
}
@@ -5186,10 +5276,10 @@ CheckChannelErrors(chanPtr, direction)
* We want to discover these conditions anew in each operation.
*/
- if ((chanPtr->flags & CHANNEL_STICKY_EOF) == 0) {
- chanPtr->flags &= ~CHANNEL_EOF;
+ if ((statePtr->flags & CHANNEL_STICKY_EOF) == 0) {
+ statePtr->flags &= ~CHANNEL_EOF;
}
- chanPtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+ statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
}
return 0;
@@ -5215,12 +5305,12 @@ int
Tcl_Eof(chan)
Tcl_Channel chan; /* Does this channel have EOF? */
{
- Channel *chanPtr; /* The real channel structure. */
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of real channel structure. */
- chanPtr = (Channel *) chan;
- return ((chanPtr->flags & CHANNEL_STICKY_EOF) ||
- ((chanPtr->flags & CHANNEL_EOF) && (Tcl_InputBuffered(chan) == 0)))
- ? 1 : 0;
+ return ((statePtr->flags & CHANNEL_STICKY_EOF) ||
+ ((statePtr->flags & CHANNEL_EOF) &&
+ (Tcl_InputBuffered(chan) == 0))) ? 1 : 0;
}
/*
@@ -5243,10 +5333,10 @@ int
Tcl_InputBlocked(chan)
Tcl_Channel chan; /* Is this channel blocked? */
{
- Channel *chanPtr; /* The real channel structure. */
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of real channel structure. */
- chanPtr = (Channel *) chan;
- return (chanPtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
+ return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
}
/*
@@ -5255,7 +5345,7 @@ Tcl_InputBlocked(chan)
* Tcl_InputBuffered --
*
* Returns the number of bytes of input currently buffered in the
- * internal buffer of a channel.
+ * common internal buffer of a channel.
*
* Results:
* The number of input bytes buffered, or zero if the channel is not
@@ -5271,16 +5361,63 @@ int
Tcl_InputBuffered(chan)
Tcl_Channel chan; /* The channel to query. */
{
- Channel *chanPtr;
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of real channel structure. */
+ ChannelBuffer *bufPtr;
int bytesBuffered;
+
+ for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ }
+
+ /*
+ * Don't forget the bytes in the topmost pushback area.
+ */
+
+ for (bufPtr = statePtr->topChanPtr->inQueueHead;
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
+ bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
+ }
+
+ return bytesBuffered;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelBuffered --
+ *
+ * Returns the number of bytes of input currently buffered in the
+ * internal buffer (push back area) of a channel.
+ *
+ * Results:
+ * The number of input bytes buffered, or zero if the channel is not
+ * open for reading.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ChannelBuffered(chan)
+ Tcl_Channel chan; /* The channel to query. */
+{
+ Channel *chanPtr = (Channel *) chan;
+ /* real channel structure. */
ChannelBuffer *bufPtr;
+ int bytesBuffered;
- chanPtr = (Channel *) chan;
for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+ bufPtr != (ChannelBuffer *) NULL;
+ bufPtr = bufPtr->nextPtr) {
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
+
return bytesBuffered;
}
@@ -5307,7 +5444,7 @@ Tcl_SetChannelBufferSize(chan, sz)
* to set. */
int sz; /* The size to set. */
{
- Channel *chanPtr;
+ ChannelState *statePtr; /* State of real channel structure. */
/*
* If the buffer size is smaller than 10 bytes or larger than one MByte,
@@ -5321,16 +5458,16 @@ Tcl_SetChannelBufferSize(chan, sz)
return;
}
- chanPtr = (Channel *) chan;
- chanPtr->bufSize = sz;
+ statePtr = ((Channel *) chan)->state;
+ statePtr->bufSize = sz;
- if (chanPtr->outputStage != NULL) {
- ckfree((char *) chanPtr->outputStage);
- chanPtr->outputStage = NULL;
+ if (statePtr->outputStage != NULL) {
+ ckfree((char *) statePtr->outputStage);
+ statePtr->outputStage = NULL;
}
- if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
- chanPtr->outputStage = (char *)
- ckalloc((unsigned) (chanPtr->bufSize + 2));
+ if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+ statePtr->outputStage = (char *)
+ ckalloc((unsigned) (statePtr->bufSize + 2));
}
}
@@ -5355,10 +5492,10 @@ Tcl_GetChannelBufferSize(chan)
Tcl_Channel chan; /* The channel for which to find the
* buffer size. */
{
- Channel *chanPtr;
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of real channel structure. */
- chanPtr = (Channel *) chan;
- return chanPtr->bufSize;
+ return statePtr->bufSize;
}
/*
@@ -5401,7 +5538,7 @@ Tcl_BadChannelOption(interp, optionName, optionList)
{
if (interp) {
CONST char *genericopt =
- "blocking buffering buffersize encoding eofchar translation";
+ "blocking buffering buffersize encoding eofchar translation";
char **argv;
int argc, i;
Tcl_DString ds;
@@ -5413,12 +5550,12 @@ Tcl_BadChannelOption(interp, optionName, optionList)
Tcl_DStringAppend(&ds, optionList, -1);
}
if (Tcl_SplitList(interp, Tcl_DStringValue(&ds),
- &argc, &argv) != TCL_OK) {
+ &argc, &argv) != TCL_OK) {
panic("malformed option list in channel driver");
}
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "bad option \"", optionName,
- "\": should be one of ", (char *) NULL);
+ "\": should be one of ", (char *) NULL);
argc--;
for (i = 0; i < argc; i++) {
Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
@@ -5461,30 +5598,39 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
size_t len; /* Length of optionName string. */
char optionVal[128]; /* Buffer for sprintf. */
Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
int flags;
/*
- * If we are in the middle of a background copy, use the saved flags.
+ * Disallow options on dead channels -- channels that have been closed but
+ * not yet been deallocated. Such channels can be found if the exit
+ * handler for channel cleanup has run but the channel is still
+ * registered in an interpreter.
*/
- if (chanPtr->csPtr) {
- if (chanPtr == chanPtr->csPtr->readPtr) {
- flags = chanPtr->csPtr->readFlags;
- } else {
- flags = chanPtr->csPtr->writeFlags;
- }
- } else {
- flags = chanPtr->flags;
+ if (CheckForDeadChannel(interp, statePtr)) {
+ return TCL_ERROR;
}
/*
- * Disallow options on dead channels -- channels that have been closed but
- * not yet been deallocated. Such channels can be found if the exit
- * handler for channel cleanup has run but the channel is still
- * registered in an interpreter.
+ * This operation should occur at the top of a channel stack.
*/
- if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR;
+ chanPtr = statePtr->topChanPtr;
+
+ /*
+ * If we are in the middle of a background copy, use the saved flags.
+ */
+
+ if (statePtr->csPtr) {
+ if (chanPtr == statePtr->csPtr->readPtr) {
+ flags = statePtr->csPtr->readFlags;
+ } else {
+ flags = statePtr->csPtr->writeFlags;
+ }
+ } else {
+ flags = statePtr->flags;
+ }
/*
* If the optionName is NULL it means that we want a list of all
@@ -5529,7 +5675,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-buffersize");
}
- TclFormatInt(optionVal, chanPtr->bufSize);
+ TclFormatInt(optionVal, statePtr->bufSize);
Tcl_DStringAppendElement(dsPtr, optionVal);
if (len > 0) {
return TCL_OK;
@@ -5541,11 +5687,11 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-encoding");
}
- if (chanPtr->encoding == NULL) {
+ if (statePtr->encoding == NULL) {
Tcl_DStringAppendElement(dsPtr, "binary");
} else {
Tcl_DStringAppendElement(dsPtr,
- Tcl_GetEncodingName(chanPtr->encoding));
+ Tcl_GetEncodingName(statePtr->encoding));
}
if (len > 0) {
return TCL_OK;
@@ -5562,22 +5708,22 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
Tcl_DStringStartSublist(dsPtr);
}
if (flags & TCL_READABLE) {
- if (chanPtr->inEofChar == 0) {
+ if (statePtr->inEofChar == 0) {
Tcl_DStringAppendElement(dsPtr, "");
} else {
char buf[4];
- sprintf(buf, "%c", chanPtr->inEofChar);
+ sprintf(buf, "%c", statePtr->inEofChar);
Tcl_DStringAppendElement(dsPtr, buf);
}
}
if (flags & TCL_WRITABLE) {
- if (chanPtr->outEofChar == 0) {
+ if (statePtr->outEofChar == 0) {
Tcl_DStringAppendElement(dsPtr, "");
} else {
char buf[4];
- sprintf(buf, "%c", chanPtr->outEofChar);
+ sprintf(buf, "%c", statePtr->outEofChar);
Tcl_DStringAppendElement(dsPtr, buf);
}
}
@@ -5600,22 +5746,22 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
Tcl_DStringStartSublist(dsPtr);
}
if (flags & TCL_READABLE) {
- if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
+ if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
Tcl_DStringAppendElement(dsPtr, "auto");
- } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
+ } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
Tcl_DStringAppendElement(dsPtr, "cr");
- } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
+ } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
Tcl_DStringAppendElement(dsPtr, "crlf");
} else {
Tcl_DStringAppendElement(dsPtr, "lf");
}
}
if (flags & TCL_WRITABLE) {
- if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
+ if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
Tcl_DStringAppendElement(dsPtr, "auto");
- } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
+ } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
Tcl_DStringAppendElement(dsPtr, "cr");
- } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
+ } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
Tcl_DStringAppendElement(dsPtr, "crlf");
} else {
Tcl_DStringAppendElement(dsPtr, "lf");
@@ -5636,7 +5782,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
*/
return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
- interp, optionName, dsPtr);
+ interp, optionName, dsPtr);
} else {
/*
* no driver specific options case.
@@ -5674,27 +5820,25 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
char *newValue; /* New value for option. */
{
int newMode; /* New (numeric) mode to sert. */
- Channel *chanPtr; /* The real IO channel. */
+ Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
size_t len; /* Length of optionName string. */
int argc;
char **argv;
-
- chanPtr = (Channel *) chan;
/*
* If the channel is in the middle of a background copy, fail.
*/
- if (chanPtr->csPtr) {
+ if (statePtr->csPtr) {
if (interp) {
Tcl_AppendResult(interp,
- "unable to set channel options: background copy in progress",
- (char *) NULL);
+ "unable to set channel options: background copy in progress",
+ (char *) NULL);
}
return TCL_ERROR;
}
-
/*
* Disallow options on dead channels -- channels that have been closed but
* not yet been deallocated. Such channels can be found if the exit
@@ -5702,8 +5846,16 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
* registered in an interpreter.
*/
- if (CheckForDeadChannel(NULL,chanPtr)) return TCL_ERROR;
-
+ if (CheckForDeadChannel(NULL, statePtr)) {
+ return TCL_ERROR;
+ }
+
+ /*
+ * This operation should occur at the top of a channel stack.
+ */
+
+ chanPtr = statePtr->topChanPtr;
+
len = strlen(optionName);
if ((len > 2) && (optionName[1] == 'b') &&
@@ -5721,16 +5873,16 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
(strncmp(optionName, "-buffering", len) == 0)) {
len = strlen(newValue);
if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
- chanPtr->flags &=
+ statePtr->flags &=
(~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
} else if ((newValue[0] == 'l') &&
(strncmp(newValue, "line", len) == 0)) {
- chanPtr->flags &= (~(CHANNEL_UNBUFFERED));
- chanPtr->flags |= CHANNEL_LINEBUFFERED;
+ statePtr->flags &= (~(CHANNEL_UNBUFFERED));
+ statePtr->flags |= CHANNEL_LINEBUFFERED;
} else if ((newValue[0] == 'n') &&
(strncmp(newValue, "none", len) == 0)) {
- chanPtr->flags &= (~(CHANNEL_LINEBUFFERED));
- chanPtr->flags |= CHANNEL_UNBUFFERED;
+ statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
+ statePtr->flags |= CHANNEL_UNBUFFERED;
} else {
if (interp) {
Tcl_AppendResult(interp, "bad value for -buffering: ",
@@ -5742,9 +5894,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
return TCL_OK;
} else if ((len > 7) && (optionName[1] == 'b') &&
(strncmp(optionName, "-buffersize", len) == 0)) {
- chanPtr->bufSize = atoi(newValue); /* INTL: "C", UTF safe. */
- if ((chanPtr->bufSize < 10) || (chanPtr->bufSize > (1024 * 1024))) {
- chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
+ statePtr->bufSize = atoi(newValue); /* INTL: "C", UTF safe. */
+ if ((statePtr->bufSize < 10) || (statePtr->bufSize > (1024 * 1024))) {
+ statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
}
} else if ((len > 2) && (optionName[1] == 'e') &&
(strncmp(optionName, "-encoding", len) == 0)) {
@@ -5758,13 +5910,13 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
return TCL_ERROR;
}
}
- Tcl_FreeEncoding(chanPtr->encoding);
- chanPtr->encoding = encoding;
- chanPtr->inputEncodingState = NULL;
- chanPtr->inputEncodingFlags = TCL_ENCODING_START;
- chanPtr->outputEncodingState = NULL;
- chanPtr->outputEncodingFlags = TCL_ENCODING_START;
- chanPtr->flags &= ~CHANNEL_NEED_MORE_DATA;
+ Tcl_FreeEncoding(statePtr->encoding);
+ statePtr->encoding = encoding;
+ statePtr->inputEncodingState = NULL;
+ statePtr->inputEncodingFlags = TCL_ENCODING_START;
+ statePtr->outputEncodingState = NULL;
+ statePtr->outputEncodingFlags = TCL_ENCODING_START;
+ statePtr->flags &= ~CHANNEL_NEED_MORE_DATA;
UpdateInterest(chanPtr);
} else if ((len > 2) && (optionName[1] == 'e') &&
(strncmp(optionName, "-eofchar", len) == 0)) {
@@ -5772,14 +5924,14 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
return TCL_ERROR;
}
if (argc == 0) {
- chanPtr->inEofChar = 0;
- chanPtr->outEofChar = 0;
+ statePtr->inEofChar = 0;
+ statePtr->outEofChar = 0;
} else if (argc == 1) {
- if (chanPtr->flags & TCL_WRITABLE) {
- chanPtr->outEofChar = (int) argv[0][0];
+ if (statePtr->flags & TCL_WRITABLE) {
+ statePtr->outEofChar = (int) argv[0][0];
}
- if (chanPtr->flags & TCL_READABLE) {
- chanPtr->inEofChar = (int) argv[0][0];
+ if (statePtr->flags & TCL_READABLE) {
+ statePtr->inEofChar = (int) argv[0][0];
}
} else if (argc != 2) {
if (interp) {
@@ -5790,11 +5942,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
ckfree((char *) argv);
return TCL_ERROR;
} else {
- if (chanPtr->flags & TCL_READABLE) {
- chanPtr->inEofChar = (int) argv[0][0];
+ if (statePtr->flags & TCL_READABLE) {
+ statePtr->inEofChar = (int) argv[0][0];
}
- if (chanPtr->flags & TCL_WRITABLE) {
- chanPtr->outEofChar = (int) argv[1][0];
+ if (statePtr->flags & TCL_WRITABLE) {
+ statePtr->outEofChar = (int) argv[1][0];
}
}
if (argv != (char **) NULL) {
@@ -5810,11 +5962,11 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
}
if (argc == 1) {
- readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
- writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
+ readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
+ writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
} else if (argc == 2) {
- readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
- writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
+ readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
+ writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
} else {
if (interp) {
Tcl_AppendResult(interp,
@@ -5827,14 +5979,14 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
if (readMode) {
if (*readMode == '\0') {
- newMode = chanPtr->inputTranslation;
+ newMode = statePtr->inputTranslation;
} else if (strcmp(readMode, "auto") == 0) {
newMode = TCL_TRANSLATE_AUTO;
} else if (strcmp(readMode, "binary") == 0) {
newMode = TCL_TRANSLATE_LF;
- chanPtr->inEofChar = 0;
- Tcl_FreeEncoding(chanPtr->encoding);
- chanPtr->encoding = NULL;
+ statePtr->inEofChar = 0;
+ Tcl_FreeEncoding(statePtr->encoding);
+ statePtr->encoding = NULL;
} else if (strcmp(readMode, "lf") == 0) {
newMode = TCL_TRANSLATE_LF;
} else if (strcmp(readMode, "cr") == 0) {
@@ -5860,10 +6012,10 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
* complete the line.
*/
- if (newMode != chanPtr->inputTranslation) {
- chanPtr->inputTranslation = (Tcl_EolTranslation) newMode;
- chanPtr->flags &= ~(INPUT_SAW_CR);
- chanPtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
+ if (newMode != statePtr->inputTranslation) {
+ statePtr->inputTranslation = (Tcl_EolTranslation) newMode;
+ statePtr->flags &= ~(INPUT_SAW_CR);
+ statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
UpdateInterest(chanPtr);
}
}
@@ -5878,24 +6030,24 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
* coded later.
*/
- if (strcmp(chanPtr->typePtr->typeName, "tcp") == 0) {
- chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
+ if (strcmp(Tcl_ChannelName(chanPtr->typePtr), "tcp") == 0) {
+ statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
} else {
- chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+ statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
}
} else if (strcmp(writeMode, "binary") == 0) {
- chanPtr->outEofChar = 0;
- chanPtr->outputTranslation = TCL_TRANSLATE_LF;
- Tcl_FreeEncoding(chanPtr->encoding);
- chanPtr->encoding = NULL;
+ statePtr->outEofChar = 0;
+ statePtr->outputTranslation = TCL_TRANSLATE_LF;
+ Tcl_FreeEncoding(statePtr->encoding);
+ statePtr->encoding = NULL;
} else if (strcmp(writeMode, "lf") == 0) {
- chanPtr->outputTranslation = TCL_TRANSLATE_LF;
+ statePtr->outputTranslation = TCL_TRANSLATE_LF;
} else if (strcmp(writeMode, "cr") == 0) {
- chanPtr->outputTranslation = TCL_TRANSLATE_CR;
+ statePtr->outputTranslation = TCL_TRANSLATE_CR;
} else if (strcmp(writeMode, "crlf") == 0) {
- chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
+ statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
} else if (strcmp(writeMode, "platform") == 0) {
- chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+ statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
} else {
if (interp) {
Tcl_AppendResult(interp,
@@ -5920,17 +6072,17 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
* If bufsize changes, need to get rid of old utility buffer.
*/
- if (chanPtr->saveInBufPtr != NULL) {
- RecycleBuffer(chanPtr, chanPtr->saveInBufPtr, 1);
- chanPtr->saveInBufPtr = NULL;
+ if (statePtr->saveInBufPtr != NULL) {
+ RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
+ statePtr->saveInBufPtr = NULL;
}
- if (chanPtr->inQueueHead != NULL) {
- if ((chanPtr->inQueueHead->nextPtr == NULL)
- && (chanPtr->inQueueHead->nextAdded ==
- chanPtr->inQueueHead->nextRemoved)) {
- RecycleBuffer(chanPtr, chanPtr->inQueueHead, 1);
- chanPtr->inQueueHead = NULL;
- chanPtr->inQueueTail = NULL;
+ if (statePtr->inQueueHead != NULL) {
+ if ((statePtr->inQueueHead->nextPtr == NULL)
+ && (statePtr->inQueueHead->nextAdded ==
+ statePtr->inQueueHead->nextRemoved)) {
+ RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
}
}
@@ -5938,13 +6090,13 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
* If encoding or bufsize changes, need to update output staging buffer.
*/
- if (chanPtr->outputStage != NULL) {
- ckfree((char *) chanPtr->outputStage);
- chanPtr->outputStage = NULL;
+ if (statePtr->outputStage != NULL) {
+ ckfree((char *) statePtr->outputStage);
+ statePtr->outputStage = NULL;
}
- if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) {
- chanPtr->outputStage = (char *)
- ckalloc((unsigned) (chanPtr->bufSize + 2));
+ if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
+ statePtr->outputStage = (char *)
+ ckalloc((unsigned) (statePtr->bufSize + 2));
}
return TCL_OK;
}
@@ -5974,6 +6126,7 @@ CleanupChannelHandlers(interp, chanPtr)
Tcl_Interp *interp;
Channel *chanPtr;
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
/*
@@ -5981,26 +6134,26 @@ CleanupChannelHandlers(interp, chanPtr)
* given interpreter.
*/
- for (sPtr = chanPtr->scriptRecordPtr,
- prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
- nextPtr = sPtr->nextPtr;
- if (sPtr->interp == interp) {
- if (prevPtr == (EventScriptRecord *) NULL) {
- chanPtr->scriptRecordPtr = nextPtr;
- } else {
- prevPtr->nextPtr = nextPtr;
- }
+ for (sPtr = statePtr->scriptRecordPtr,
+ prevPtr = (EventScriptRecord *) NULL;
+ sPtr != (EventScriptRecord *) NULL;
+ sPtr = nextPtr) {
+ nextPtr = sPtr->nextPtr;
+ if (sPtr->interp == interp) {
+ if (prevPtr == (EventScriptRecord *) NULL) {
+ statePtr->scriptRecordPtr = nextPtr;
+ } else {
+ prevPtr->nextPtr = nextPtr;
+ }
- Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
- TclChannelEventScriptInvoker, (ClientData) sPtr);
+ Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+ TclChannelEventScriptInvoker, (ClientData) sPtr);
Tcl_DecrRefCount(sPtr->scriptPtr);
- ckfree((char *) sPtr);
- } else {
- prevPtr = sPtr;
- }
+ ckfree((char *) sPtr);
+ } else {
+ prevPtr = sPtr;
+ }
}
}
@@ -6010,7 +6163,7 @@ CleanupChannelHandlers(interp, chanPtr)
* Tcl_NotifyChannel --
*
* This procedure is called by a channel driver when a driver
- * detects an event on a channel. This procedure is responsible
+ * detects an event on a channel. This procedure is responsible
* for actually handling the event by invoking any channel
* handler callbacks.
*
@@ -6031,28 +6184,138 @@ Tcl_NotifyChannel(channel, mask)
* which events were detected. */
{
Channel *chanPtr = (Channel *) channel;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelHandler *chPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
NextChannelHandler nh;
+#ifdef TCL_CHANNEL_VERSION_2
+ Channel* upChanPtr;
+ Tcl_ChannelType* upTypePtr;
+
+ /*
+ * In contrast to the other API functions this procedure walks towards
+ * the top of a stack and not down from it.
+ *
+ * The channel calling this procedure is the one who generated the event,
+ * and thus does not take part in handling it. IOW, its HandlerProc is
+ * not called, instead we begin with the channel above it.
+ *
+ * This behaviour also allows the transformation channels to
+ * generate their own events and pass them upward.
+ */
+
+ while (mask && (chanPtr->upChanPtr != ((Channel*) NULL))) {
+ upChanPtr = chanPtr->upChanPtr;
+ upTypePtr = upChanPtr->typePtr;
+
+ if ((Tcl_ChannelVersion(upTypePtr) == TCL_CHANNEL_VERSION_2) &&
+ (Tcl_ChannelHandlerProc(upTypePtr) !=
+ ((Tcl_DriverHandlerProc *) NULL))) {
+
+ Tcl_DriverHandlerProc* handlerProc =
+ Tcl_ChannelHandlerProc(upTypePtr);
+
+ mask = (*handlerProc) (upChanPtr->instanceData, mask);
+ }
+
+ /* ELSE:
+ * Ignore transformations which are unable to handle the event
+ * coming from below. Assume that they don't change the mask and
+ * pass it on.
+ */
+
+ chanPtr = upChanPtr;
+ }
+
+ channel = (Tcl_Channel) chanPtr;
+ /*
+ * Here we have either reached the top of the stack or the mask is
+ * empty. We break out of the procedure if it is the latter.
+ */
+
+ if (!mask) {
+ return;
+ }
+
+ /*
+ * We are now above the topmost channel in a stack and have events
+ * left. Now call the channel handlers as usual.
+ *
+ * Preserve the channel struct in case the script closes it.
+ */
+
+ Tcl_Preserve((ClientData) channel);
+
+ /*
+ * If we are flushing in the background, be sure to call FlushChannel
+ * for writable events. Note that we have to discard the writable
+ * event so we don't call any write handlers before the flush is
+ * complete.
+ */
+
+ if ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
+ FlushChannel(NULL, chanPtr, 1);
+ mask &= ~TCL_WRITABLE;
+ }
+
+ /*
+ * Add this invocation to the list of recursive invocations of
+ * ChannelHandlerEventProc.
+ */
+
+ nh.nextHandlerPtr = (ChannelHandler *) NULL;
+ nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
+ tsdPtr->nestedHandlerPtr = &nh;
+
+ for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
+
+ /*
+ * If this channel handler is interested in any of the events that
+ * have occurred on the channel, invoke its procedure.
+ */
+
+ if ((chPtr->mask & mask) != 0) {
+ nh.nextHandlerPtr = chPtr->nextPtr;
+ (*(chPtr->proc))(chPtr->clientData, mask);
+ chPtr = nh.nextHandlerPtr;
+ } else {
+ chPtr = chPtr->nextPtr;
+ }
+ }
+
+ /*
+ * Update the notifier interest, since it may have changed after
+ * invoking event handlers. Skip that if the channel was deleted
+ * in the call to the channel handler.
+ */
+
+ if (chanPtr->typePtr != NULL) {
+ UpdateInterest(chanPtr);
+ }
+
+ Tcl_Release((ClientData) channel);
+
+ tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr;
+#else
/* Walk all channels in a stack ! and notify them in order.
*/
- while (chanPtr != (Channel *) NULL) {
- /*
+ while (chanPtr != (Channel *) NULL) {
+ /*
* Preserve the channel struct in case the script closes it.
*/
- Tcl_Preserve((ClientData) channel);
+ Tcl_Preserve((ClientData) channel);
/*
* If we are flushing in the background, be sure to call FlushChannel
- * for writable events. Note that we have to discard the writable
+ * 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 ((chanPtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
+ if ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
FlushChannel(NULL, chanPtr, 1);
mask &= ~TCL_WRITABLE;
}
@@ -6065,21 +6328,21 @@ Tcl_NotifyChannel(channel, mask)
nh.nextHandlerPtr = (ChannelHandler *) NULL;
nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
tsdPtr->nestedHandlerPtr = &nh;
-
- for (chPtr = chanPtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
+
+ for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
/*
* If this channel handler is interested in any of the events that
* have occurred on the channel, invoke its procedure.
*/
-
- if ((chPtr->mask & mask) != 0) {
- nh.nextHandlerPtr = chPtr->nextPtr;
- (*(chPtr->proc))(chPtr->clientData, mask);
- chPtr = nh.nextHandlerPtr;
- } else {
- chPtr = chPtr->nextPtr;
- }
+
+ if ((chPtr->mask & mask) != 0) {
+ nh.nextHandlerPtr = chPtr->nextPtr;
+ (*(chPtr->proc))(chPtr->clientData, mask);
+ chPtr = nh.nextHandlerPtr;
+ } else {
+ chPtr = chPtr->nextPtr;
+ }
}
/*
@@ -6093,11 +6356,11 @@ Tcl_NotifyChannel(channel, mask)
/* Walk down the stack.
*/
- chanPtr = chanPtr-> supercedes;
+ chanPtr = chanPtr->downChanPtr;
} else {
/* Stop walking the chain, the whole stack was destroyed!
*/
- chanPtr = (Channel*) NULL;
+ chanPtr = (Channel *) NULL;
}
Tcl_Release((ClientData) channel);
@@ -6106,6 +6369,7 @@ Tcl_NotifyChannel(channel, mask)
channel = (Tcl_Channel) chanPtr;
}
+#endif
}
/*
@@ -6129,14 +6393,15 @@ static void
UpdateInterest(chanPtr)
Channel *chanPtr; /* Channel to update. */
{
- int mask = chanPtr->interestMask;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ int mask = statePtr->interestMask;
/*
* If there are flushed buffers waiting to be written, then
* we need to watch for the channel to become writable.
*/
- if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
+ if (statePtr->flags & BG_FLUSH_SCHEDULED) {
mask |= TCL_WRITABLE;
}
@@ -6148,13 +6413,13 @@ UpdateInterest(chanPtr)
*/
if (mask & TCL_READABLE) {
- if (!(chanPtr->flags & CHANNEL_NEED_MORE_DATA)
- && (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
- && (chanPtr->inQueueHead->nextRemoved <
- chanPtr->inQueueHead->nextAdded)) {
+ if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
+ && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+ && (statePtr->inQueueHead->nextRemoved <
+ statePtr->inQueueHead->nextAdded)) {
mask &= ~TCL_READABLE;
- if (!chanPtr->timer) {
- chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
+ if (!statePtr->timer) {
+ statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
(ClientData) chanPtr);
}
}
@@ -6184,23 +6449,24 @@ ChannelTimerProc(clientData)
ClientData clientData;
{
Channel *chanPtr = (Channel *) clientData;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
- if (!(chanPtr->flags & CHANNEL_NEED_MORE_DATA)
- && (chanPtr->interestMask & TCL_READABLE)
- && (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
- && (chanPtr->inQueueHead->nextRemoved <
- chanPtr->inQueueHead->nextAdded)) {
+ if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
+ && (statePtr->interestMask & TCL_READABLE)
+ && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+ && (statePtr->inQueueHead->nextRemoved <
+ statePtr->inQueueHead->nextAdded)) {
/*
* Restart the timer in case a channel handler reenters the
* event loop before UpdateInterest gets called by Tcl_NotifyChannel.
*/
- chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
- (ClientData) chanPtr);
+ statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
+ (ClientData) chanPtr);
Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE);
- } else {
- chanPtr->timer = NULL;
+ } else {
+ statePtr->timer = NULL;
UpdateInterest(chanPtr);
}
}
@@ -6234,38 +6500,37 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
* TCL_WRITABLE, and TCL_EXCEPTION:
* indicates conditions under which
* proc should be called. Use 0 to
- * disable a registered handler. */
+ * disable a registered handler. */
Tcl_ChannelProc *proc; /* Procedure to call for each
* selected event. */
ClientData clientData; /* Arbitrary data to pass to proc. */
{
ChannelHandler *chPtr;
- Channel *chanPtr;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
- chanPtr = (Channel *) chan;
-
/*
* Check whether this channel handler is not already registered. If
* it is not, create a new record, else reuse existing record (smash
* current values).
*/
- for (chPtr = chanPtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
- (chPtr->clientData == clientData)) {
- break;
- }
+ for (chPtr = statePtr->chPtr;
+ chPtr != (ChannelHandler *) NULL;
+ chPtr = chPtr->nextPtr) {
+ if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
+ (chPtr->clientData == clientData)) {
+ break;
+ }
}
if (chPtr == (ChannelHandler *) NULL) {
- chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
- chPtr->mask = 0;
- chPtr->proc = proc;
- chPtr->clientData = clientData;
- chPtr->chanPtr = chanPtr;
- chPtr->nextPtr = chanPtr->chPtr;
- chanPtr->chPtr = chPtr;
+ chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
+ chPtr->mask = 0;
+ chPtr->proc = proc;
+ chPtr->clientData = clientData;
+ chPtr->chanPtr = chanPtr;
+ chPtr->nextPtr = statePtr->chPtr;
+ statePtr->chPtr = chPtr;
}
/*
@@ -6281,14 +6546,14 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
* be disabling an existing handler.
*/
- chanPtr->interestMask = 0;
- for (chPtr = chanPtr->chPtr;
+ statePtr->interestMask = 0;
+ for (chPtr = statePtr->chPtr;
chPtr != (ChannelHandler *) NULL;
chPtr = chPtr->nextPtr) {
- chanPtr->interestMask |= chPtr->mask;
+ statePtr->interestMask |= chPtr->mask;
}
- UpdateInterest(chanPtr);
+ UpdateInterest(statePtr->topChanPtr);
}
/*
@@ -6313,39 +6578,38 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
void
Tcl_DeleteChannelHandler(chan, proc, clientData)
Tcl_Channel chan; /* The channel for which to remove the
- * callback. */
+ * callback. */
Tcl_ChannelProc *proc; /* The procedure in the callback to delete. */
ClientData clientData; /* The client data in the callback
- * to delete. */
+ * to delete. */
{
- ChannelHandler *chPtr, *prevChPtr;
- Channel *chanPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelHandler *chPtr, *prevChPtr;
+ Channel *chanPtr = (Channel *) chan;
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
NextChannelHandler *nhPtr;
- chanPtr = (Channel *) chan;
-
/*
* Find the entry and the previous one in the list.
*/
- for (prevChPtr = (ChannelHandler *) NULL, chPtr = chanPtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
- && (chPtr->proc == proc)) {
- break;
- }
- prevChPtr = chPtr;
+ for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr;
+ chPtr != (ChannelHandler *) NULL;
+ chPtr = chPtr->nextPtr) {
+ if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
+ && (chPtr->proc == proc)) {
+ break;
+ }
+ prevChPtr = chPtr;
}
-
+
/*
* If not found, return without doing anything.
*/
if (chPtr == (ChannelHandler *) NULL) {
- return;
+ return;
}
/*
@@ -6354,11 +6618,11 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
*/
for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
- nhPtr = nhPtr->nestedHandlerPtr) {
- if (nhPtr->nextHandlerPtr == chPtr) {
- nhPtr->nextHandlerPtr = chPtr->nextPtr;
- }
+ nhPtr != (NextChannelHandler *) NULL;
+ nhPtr = nhPtr->nestedHandlerPtr) {
+ if (nhPtr->nextHandlerPtr == chPtr) {
+ nhPtr->nextHandlerPtr = chPtr->nextPtr;
+ }
}
/*
@@ -6366,9 +6630,9 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
*/
if (prevChPtr == (ChannelHandler *) NULL) {
- chanPtr->chPtr = chPtr->nextPtr;
+ statePtr->chPtr = chPtr->nextPtr;
} else {
- prevChPtr->nextPtr = chPtr->nextPtr;
+ prevChPtr->nextPtr = chPtr->nextPtr;
}
ckfree((char *) chPtr);
@@ -6378,14 +6642,14 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* event.
*/
- chanPtr->interestMask = 0;
- for (chPtr = chanPtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
- chanPtr->interestMask |= chPtr->mask;
+ statePtr->interestMask = 0;
+ for (chPtr = statePtr->chPtr;
+ chPtr != (ChannelHandler *) NULL;
+ chPtr = chPtr->nextPtr) {
+ statePtr->interestMask |= chPtr->mask;
}
- UpdateInterest(chanPtr);
+ UpdateInterest(statePtr->topChanPtr);
}
/*
@@ -6408,33 +6672,34 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
static void
DeleteScriptRecord(interp, chanPtr, mask)
Tcl_Interp *interp; /* Interpreter in which script was to be
- * executed. */
+ * executed. */
Channel *chanPtr; /* The channel for which to delete the
- * script record (if any). */
+ * script record (if any). */
int mask; /* Events in mask must exactly match mask
- * of script to delete. */
+ * of script to delete. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *esPtr, *prevEsPtr;
- for (esPtr = chanPtr->scriptRecordPtr,
- prevEsPtr = (EventScriptRecord *) NULL;
- esPtr != (EventScriptRecord *) NULL;
- prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
- if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
- if (esPtr == chanPtr->scriptRecordPtr) {
- chanPtr->scriptRecordPtr = esPtr->nextPtr;
- } else {
- prevEsPtr->nextPtr = esPtr->nextPtr;
- }
+ for (esPtr = statePtr->scriptRecordPtr,
+ prevEsPtr = (EventScriptRecord *) NULL;
+ esPtr != (EventScriptRecord *) NULL;
+ prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
+ if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+ if (esPtr == statePtr->scriptRecordPtr) {
+ statePtr->scriptRecordPtr = esPtr->nextPtr;
+ } else {
+ prevEsPtr->nextPtr = esPtr->nextPtr;
+ }
- Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
- TclChannelEventScriptInvoker, (ClientData) esPtr);
-
+ Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+ TclChannelEventScriptInvoker, (ClientData) esPtr);
+
Tcl_DecrRefCount(esPtr->scriptPtr);
- ckfree((char *) esPtr);
+ ckfree((char *) esPtr);
- break;
- }
+ break;
+ }
}
}
@@ -6458,31 +6723,32 @@ DeleteScriptRecord(interp, chanPtr, mask)
static void
CreateScriptRecord(interp, chanPtr, mask, scriptPtr)
Tcl_Interp *interp; /* Interpreter in which to execute
- * the stored script. */
+ * the stored script. */
Channel *chanPtr; /* Channel for which script is to
- * be stored. */
+ * be stored. */
int mask; /* Set of events for which script
- * will be invoked. */
+ * will be invoked. */
Tcl_Obj *scriptPtr; /* Pointer to script object. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *esPtr;
- for (esPtr = chanPtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
- esPtr = esPtr->nextPtr) {
- if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+ for (esPtr = statePtr->scriptRecordPtr;
+ esPtr != (EventScriptRecord *) NULL;
+ esPtr = esPtr->nextPtr) {
+ if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
Tcl_DecrRefCount(esPtr->scriptPtr);
esPtr->scriptPtr = (Tcl_Obj *) NULL;
- break;
- }
+ break;
+ }
}
if (esPtr == (EventScriptRecord *) NULL) {
- esPtr = (EventScriptRecord *) ckalloc((unsigned)
- sizeof(EventScriptRecord));
- Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
- TclChannelEventScriptInvoker, (ClientData) esPtr);
- esPtr->nextPtr = chanPtr->scriptRecordPtr;
- chanPtr->scriptRecordPtr = esPtr;
+ esPtr = (EventScriptRecord *) ckalloc((unsigned)
+ sizeof(EventScriptRecord));
+ Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
+ TclChannelEventScriptInvoker, (ClientData) esPtr);
+ esPtr->nextPtr = statePtr->scriptRecordPtr;
+ statePtr->scriptRecordPtr = esPtr;
}
esPtr->chanPtr = chanPtr;
esPtr->interp = interp;
@@ -6516,17 +6782,16 @@ TclChannelEventScriptInvoker(clientData, mask)
{
Tcl_Interp *interp; /* Interpreter in which to eval the script. */
Channel *chanPtr; /* The channel for which this handler is
- * registered. */
+ * registered. */
EventScriptRecord *esPtr; /* The event script + interpreter to eval it
- * in. */
+ * in. */
int result; /* Result of call to eval script. */
- esPtr = (EventScriptRecord *) clientData;
+ esPtr = (EventScriptRecord *) clientData;
+ chanPtr = esPtr->chanPtr;
+ mask = esPtr->mask;
+ interp = esPtr->interp;
- chanPtr = esPtr->chanPtr;
- mask = esPtr->mask;
- interp = esPtr->interp;
-
/*
* We must preserve the interpreter so we can report errors on it
* later. Note that we do not need to preserve the channel because
@@ -6548,7 +6813,7 @@ TclChannelEventScriptInvoker(clientData, mask)
if (chanPtr->typePtr != NULL) {
DeleteScriptRecord(interp, chanPtr, mask);
}
- Tcl_BackgroundError(interp);
+ Tcl_BackgroundError(interp);
}
Tcl_Release((ClientData) interp);
}
@@ -6577,13 +6842,14 @@ int
Tcl_FileEventObjCmd(clientData, interp, objc, objv)
ClientData clientData; /* Not used. */
Tcl_Interp *interp; /* Interpreter in which the channel
- * for which to create the handler
- * is found. */
+ * for which to create the handler
+ * is found. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
Channel *chanPtr; /* The channel to create
- * the handler for. */
+ * the handler for. */
+ ChannelState *statePtr; /* state info for channel */
Tcl_Channel chan; /* The opaque type for the channel. */
char *chanName;
int modeIndex; /* Index of mode argument. */
@@ -6606,12 +6872,13 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
if (chan == (Tcl_Channel) NULL) {
return TCL_ERROR;
}
- chanPtr = (Channel *) chan;
- if ((chanPtr->flags & mask) == 0) {
- Tcl_AppendResult(interp, "channel is not ",
- (mask == TCL_READABLE) ? "readable" : "writable",
- (char *) NULL);
- return TCL_ERROR;
+ chanPtr = (Channel *) chan;
+ statePtr = chanPtr->state;
+ if ((statePtr->flags & mask) == 0) {
+ Tcl_AppendResult(interp, "channel is not ",
+ (mask == TCL_READABLE) ? "readable" : "writable",
+ (char *) NULL);
+ return TCL_ERROR;
}
/*
@@ -6620,15 +6887,15 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
if (objc == 3) {
EventScriptRecord *esPtr;
- for (esPtr = chanPtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
- esPtr = esPtr->nextPtr) {
+ for (esPtr = statePtr->scriptRecordPtr;
+ esPtr != (EventScriptRecord *) NULL;
+ esPtr = esPtr->nextPtr) {
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
Tcl_SetObjResult(interp, esPtr->scriptPtr);
break;
}
}
- return TCL_OK;
+ return TCL_OK;
}
/*
@@ -6636,8 +6903,8 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
*/
if (*(Tcl_GetString(objv[3])) == '\0') {
- DeleteScriptRecord(interp, chanPtr, mask);
- return TCL_OK;
+ DeleteScriptRecord(interp, chanPtr, mask);
+ return TCL_OK;
}
/*
@@ -6658,7 +6925,7 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
*
* This routine copies data from one channel to another, either
* synchronously or asynchronously. If a command script is
- * supplied, the operation runs in the background. The script
+ * supplied, the operation runs in the background. The script
* is invoked when the copy completes. Otherwise the function
* waits until the copy is completed before returning.
*
@@ -6682,26 +6949,30 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
{
Channel *inPtr = (Channel *) inChan;
Channel *outPtr = (Channel *) outChan;
+ ChannelState *inStatePtr, *outStatePtr;
int readFlags, writeFlags;
CopyState *csPtr;
int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
- if (inPtr->csPtr) {
+ inStatePtr = inPtr->state;
+ outStatePtr = outPtr->state;
+
+ if (inStatePtr->csPtr) {
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
Tcl_GetChannelName(inChan), "\" is busy", NULL);
return TCL_ERROR;
}
- if (outPtr->csPtr) {
+ if (outStatePtr->csPtr) {
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
Tcl_GetChannelName(outChan), "\" is busy", NULL);
return TCL_ERROR;
}
- readFlags = inPtr->flags;
- writeFlags = outPtr->flags;
+ readFlags = inStatePtr->flags;
+ writeFlags = outStatePtr->flags;
/*
- * Set up the blocking mode appropriately. Background copies need
+ * Set up the blocking mode appropriately. Background copies need
* non-blocking channels. Foreground copies need blocking channels.
* If there is an error, restore the old blocking mode.
*/
@@ -6732,7 +7003,7 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
* Make sure the output side is unbuffered.
*/
- outPtr->flags = (outPtr->flags & ~(CHANNEL_LINEBUFFERED))
+ outStatePtr->flags = (outStatePtr->flags & ~(CHANNEL_LINEBUFFERED))
| CHANNEL_UNBUFFERED;
/*
@@ -6741,21 +7012,21 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
* completed.
*/
- csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inPtr->bufSize);
- csPtr->bufSize = inPtr->bufSize;
- csPtr->readPtr = inPtr;
- csPtr->writePtr = outPtr;
- csPtr->readFlags = readFlags;
+ csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inStatePtr->bufSize);
+ csPtr->bufSize = inStatePtr->bufSize;
+ csPtr->readPtr = inPtr;
+ csPtr->writePtr = outPtr;
+ csPtr->readFlags = readFlags;
csPtr->writeFlags = writeFlags;
- csPtr->toRead = toRead;
- csPtr->total = 0;
- csPtr->interp = interp;
+ csPtr->toRead = toRead;
+ csPtr->total = 0;
+ csPtr->interp = interp;
if (cmdPtr) {
Tcl_IncrRefCount(cmdPtr);
}
csPtr->cmdPtr = cmdPtr;
- inPtr->csPtr = csPtr;
- outPtr->csPtr = csPtr;
+ inStatePtr->csPtr = csPtr;
+ outStatePtr->csPtr = csPtr;
/*
* Start copying data between the channels.
@@ -6789,17 +7060,24 @@ CopyData(csPtr, mask)
Tcl_Interp *interp;
Tcl_Obj *cmdPtr, *errObj = NULL;
Tcl_Channel inChan, outChan;
+ ChannelState *inStatePtr, *outStatePtr;
int result = TCL_OK;
int size;
int total;
- inChan = (Tcl_Channel)csPtr->readPtr;
- outChan = (Tcl_Channel)csPtr->writePtr;
- interp = csPtr->interp;
- cmdPtr = csPtr->cmdPtr;
+ inChan = (Tcl_Channel) csPtr->readPtr;
+ outChan = (Tcl_Channel) csPtr->writePtr;
+ inStatePtr = csPtr->readPtr->state;
+ outStatePtr = csPtr->writePtr->state;
+ interp = csPtr->interp;
+ cmdPtr = csPtr->cmdPtr;
/*
* Copy the data the slow way, using the translation mechanism.
+ *
+ * Note: We have make sure that we use the topmost channel in a stack
+ * for the copying. The caller uses Tcl_GetChannel to access it, and
+ * thus gets the bottom of the stack.
*/
while (csPtr->toRead != 0) {
@@ -6808,14 +7086,14 @@ CopyData(csPtr, mask)
* Check for unreported background errors.
*/
- if (csPtr->readPtr->unreportedError != 0) {
- Tcl_SetErrno(csPtr->readPtr->unreportedError);
- csPtr->readPtr->unreportedError = 0;
+ if (inStatePtr->unreportedError != 0) {
+ Tcl_SetErrno(inStatePtr->unreportedError);
+ inStatePtr->unreportedError = 0;
goto readError;
}
- if (csPtr->writePtr->unreportedError != 0) {
- Tcl_SetErrno(csPtr->writePtr->unreportedError);
- csPtr->writePtr->unreportedError = 0;
+ if (outStatePtr->unreportedError != 0) {
+ Tcl_SetErrno(outStatePtr->unreportedError);
+ outStatePtr->unreportedError = 0;
goto writeError;
}
@@ -6823,13 +7101,12 @@ CopyData(csPtr, mask)
* Read up to bufSize bytes.
*/
- if ((csPtr->toRead == -1)
- || (csPtr->toRead > csPtr->bufSize)) {
+ if ((csPtr->toRead == -1) || (csPtr->toRead > csPtr->bufSize)) {
size = csPtr->bufSize;
} else {
size = csPtr->toRead;
}
- size = DoRead(csPtr->readPtr, csPtr->buffer, size);
+ size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, size);
if (size < 0) {
readError:
@@ -6862,7 +7139,7 @@ CopyData(csPtr, mask)
* Now write the buffer out.
*/
- size = DoWrite(csPtr->writePtr, csPtr->buffer, size);
+ size = DoWrite(outStatePtr->topChanPtr, csPtr->buffer, size);
if (size < 0) {
writeError:
errObj = Tcl_NewObj();
@@ -6877,7 +7154,7 @@ CopyData(csPtr, mask)
* stop copying and wait for the channel to become writable again.
*/
- if (csPtr->writePtr->flags & BG_FLUSH_SCHEDULED) {
+ if (outStatePtr->flags & BG_FLUSH_SCHEDULED) {
if (!(mask & TCL_WRITABLE)) {
if (mask & TCL_READABLE) {
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
@@ -6926,7 +7203,7 @@ CopyData(csPtr, mask)
if (cmdPtr) {
/*
* Get a private copy of the command so we can mutate it
- * by adding arguments. Note that StopCopy frees our saved
+ * by adding arguments. Note that StopCopy frees our saved
* reference to the original command obj.
*/
@@ -6981,47 +7258,48 @@ DoRead(chanPtr, bufPtr, toRead)
char *bufPtr; /* Where to store input read. */
int toRead; /* Maximum number of bytes to read. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
int copied; /* How many characters were copied into
- * the result string? */
+ * the result string? */
int copiedNow; /* How many characters were copied from
- * the current input buffer? */
+ * the current input buffer? */
int result; /* Of calling GetInput. */
-
+
/*
* If we have not encountered a sticky EOF, clear the EOF bit. Either
* way clear the BLOCKED bit. We want to discover these anew during
* each operation.
*/
- if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
- chanPtr->flags &= ~CHANNEL_EOF;
+ if (!(statePtr->flags & CHANNEL_STICKY_EOF)) {
+ statePtr->flags &= ~CHANNEL_EOF;
}
- chanPtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
+ statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
for (copied = 0; copied < toRead; copied += copiedNow) {
- copiedNow = CopyAndTranslateBuffer(chanPtr, bufPtr + copied,
- toRead - copied);
- if (copiedNow == 0) {
- if (chanPtr->flags & CHANNEL_EOF) {
+ copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied,
+ toRead - copied);
+ if (copiedNow == 0) {
+ if (statePtr->flags & CHANNEL_EOF) {
goto done;
- }
- if (chanPtr->flags & CHANNEL_BLOCKED) {
- if (chanPtr->flags & CHANNEL_NONBLOCKING) {
+ }
+ if (statePtr->flags & CHANNEL_BLOCKED) {
+ if (statePtr->flags & CHANNEL_NONBLOCKING) {
goto done;
- }
- chanPtr->flags &= (~(CHANNEL_BLOCKED));
- }
- result = GetInput(chanPtr);
- if (result != 0) {
- if (result != EAGAIN) {
- copied = -1;
- }
+ }
+ statePtr->flags &= (~(CHANNEL_BLOCKED));
+ }
+ result = GetInput(chanPtr);
+ if (result != 0) {
+ if (result != EAGAIN) {
+ copied = -1;
+ }
goto done;
- }
- }
+ }
+ }
}
- chanPtr->flags &= (~(CHANNEL_BLOCKED));
+ statePtr->flags &= (~(CHANNEL_BLOCKED));
done:
/*
@@ -7053,17 +7331,17 @@ DoRead(chanPtr, bufPtr, toRead)
*/
static int
-CopyAndTranslateBuffer(chanPtr, result, space)
- Channel *chanPtr; /* The channel from which to read input. */
+CopyAndTranslateBuffer(statePtr, result, space)
+ ChannelState *statePtr; /* Channel state from which to read input. */
char *result; /* Where to store the copied input. */
int space; /* How many bytes are available in result
* to store the copied input? */
{
+ ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
int bytesInBuffer; /* How many bytes are available to be
* copied in the current input buffer? */
int copied; /* How many characters were already copied
* into the destination space? */
- ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
int i; /* Iterates over the copied input looking
* for the input eofChar. */
@@ -7074,14 +7352,14 @@ CopyAndTranslateBuffer(chanPtr, result, space)
* Note also that if the buffer is empty, we leave it in the queue.
*/
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+ if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
return 0;
}
- bufPtr = chanPtr->inQueueHead;
+ bufPtr = statePtr->inQueueHead;
bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
copied = 0;
- switch (chanPtr->inputTranslation) {
+ switch (statePtr->inputTranslation) {
case TCL_TRANSLATE_LF: {
if (bytesInBuffer == 0) {
return 0;
@@ -7138,10 +7416,10 @@ CopyAndTranslateBuffer(chanPtr, result, space)
*/
if (bytesInBuffer == 0) {
- if ((chanPtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
+ if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
(INPUT_SAW_CR | CHANNEL_EOF)) {
result[0] = '\r';
- chanPtr->flags &= ~INPUT_SAW_CR;
+ statePtr->flags &= ~INPUT_SAW_CR;
return 1;
}
return 0;
@@ -7166,14 +7444,14 @@ CopyAndTranslateBuffer(chanPtr, result, space)
for (src = result; src < end; src++) {
curByte = *src;
if (curByte == '\n') {
- chanPtr->flags &= ~INPUT_SAW_CR;
- } else if (chanPtr->flags & INPUT_SAW_CR) {
- chanPtr->flags &= ~INPUT_SAW_CR;
+ statePtr->flags &= ~INPUT_SAW_CR;
+ } else if (statePtr->flags & INPUT_SAW_CR) {
+ statePtr->flags &= ~INPUT_SAW_CR;
*dst = '\r';
dst++;
}
if (curByte == '\r') {
- chanPtr->flags |= INPUT_SAW_CR;
+ statePtr->flags |= INPUT_SAW_CR;
} else {
*dst = (char) curByte;
dst++;
@@ -7209,16 +7487,16 @@ CopyAndTranslateBuffer(chanPtr, result, space)
for (src = result; src < end; src++) {
curByte = *src;
if (curByte == '\r') {
- chanPtr->flags |= INPUT_SAW_CR;
+ statePtr->flags |= INPUT_SAW_CR;
*dst = '\n';
dst++;
} else {
if ((curByte != '\n') ||
- !(chanPtr->flags & INPUT_SAW_CR)) {
+ !(statePtr->flags & INPUT_SAW_CR)) {
*dst = (char) curByte;
dst++;
}
- chanPtr->flags &= ~INPUT_SAW_CR;
+ statePtr->flags &= ~INPUT_SAW_CR;
}
}
copied = dst - result;
@@ -7235,16 +7513,16 @@ CopyAndTranslateBuffer(chanPtr, result, space)
* copy only up to and excluding that character.
*/
- if (chanPtr->inEofChar != 0) {
+ if (statePtr->inEofChar != 0) {
for (i = 0; i < copied; i++) {
- if (result[i] == (char) chanPtr->inEofChar) {
+ if (result[i] == (char) statePtr->inEofChar) {
/*
* Set sticky EOF so that no further input is presented
* to the caller.
*/
- chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
- chanPtr->inputEncodingFlags |= TCL_ENCODING_END;
+ statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->inputEncodingFlags |= TCL_ENCODING_END;
copied = i;
break;
}
@@ -7256,17 +7534,109 @@ CopyAndTranslateBuffer(chanPtr, result, space)
*/
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
+ statePtr->inQueueHead = bufPtr->nextPtr;
+ if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->inQueueTail = (ChannelBuffer *) NULL;
+ }
+ RecycleBuffer(statePtr, bufPtr, 0);
+ }
+
+ /*
+ * Return the number of characters copied into the result buffer.
+ * This may be different from the number of bytes consumed, because
+ * of EOL translations.
+ */
+
+ return copied;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CopyBuffer --
+ *
+ * Copy at most one buffer of input to the result space.
+ *
+ * Results:
+ * Number of bytes stored in the result buffer. May return
+ * zero if no input is available.
+ *
+ * Side effects:
+ * Consumes buffered input. May deallocate one buffer.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CopyBuffer(chanPtr, result, space)
+ Channel *chanPtr; /* Channel from which to read input. */
+ char *result; /* Where to store the copied input. */
+ int space; /* How many bytes are available in result
+ * to store the copied input? */
+{
+ ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
+ int bytesInBuffer; /* How many bytes are available to be
+ * copied in the current input buffer? */
+ int copied; /* How many characters were already copied
+ * into the destination space? */
+
+ /*
+ * If there is no input at all, return zero. The invariant is that
+ * either there is no buffer in the queue, or if the first buffer
+ * is empty, it is also the last buffer (and thus there is no
+ * input in the queue). Note also that if the buffer is empty, we
+ * don't leave it in the queue, but recycle it.
+ */
+
+ if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+ return 0;
+ }
+ bufPtr = chanPtr->inQueueHead;
+ bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
+
+ copied = 0;
+
+ if (bytesInBuffer == 0) {
+ RecycleBuffer(chanPtr->state, bufPtr, 0);
+ chanPtr->inQueueHead = (ChannelBuffer*) NULL;
+ chanPtr->inQueueTail = (ChannelBuffer*) NULL;
+ return 0;
+ }
+
+ /*
+ * Copy the current chunk into the result buffer.
+ */
+
+ if (bytesInBuffer < space) {
+ space = bytesInBuffer;
+ }
+
+ memcpy((VOID *) result,
+ (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
+ (size_t) space);
+ bufPtr->nextRemoved += space;
+ copied = space;
+
+ /*
+ * We don't care about in-stream EOF characters here as the data
+ * read here may still flow through one or more transformations,
+ * i.e. is not in its final state yet.
+ */
+
+ /*
+ * If the current buffer is empty recycle it.
+ */
+
+ if (bufPtr->nextRemoved == bufPtr->nextAdded) {
chanPtr->inQueueHead = bufPtr->nextPtr;
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
}
- RecycleBuffer(chanPtr, bufPtr, 0);
+ RecycleBuffer(chanPtr->state, bufPtr, 0);
}
/*
* Return the number of characters copied into the result buffer.
- * This may be different from the number of bytes consumed, because
- * of EOL translations.
*/
return copied;
@@ -7299,22 +7669,23 @@ DoWrite(chanPtr, src, srcLen)
char *src; /* Data to write. */
int srcLen; /* Number of bytes to write. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *outBufPtr; /* Current output buffer. */
int foundNewline; /* Did we find a newline in output? */
char *dPtr;
char *sPtr; /* Search variables for newline. */
int crsent; /* In CRLF eol translation mode,
- * remember the fact that a CR was
- * output to the channel without
- * its following NL. */
+ * remember the fact that a CR was
+ * output to the channel without
+ * its following NL. */
int i; /* Loop index for newline search. */
int destCopied; /* How many bytes were used in this
- * destination buffer to hold the
- * output? */
+ * destination buffer to hold the
+ * output? */
int totalDestCopied; /* How many bytes total were
- * copied to the channel buffer? */
+ * copied to the channel buffer? */
int srcCopied; /* How many bytes were copied from
- * the source string? */
+ * the source string? */
char *destPtr; /* Where in line to copy to? */
/*
@@ -7333,97 +7704,97 @@ DoWrite(chanPtr, src, srcLen)
totalDestCopied = 0;
while (srcLen > 0) {
-
- /*
- * Make sure there is a current output buffer to accept output.
- */
+
+ /*
+ * Make sure there is a current output buffer to accept output.
+ */
- if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
- chanPtr->curOutPtr = AllocChannelBuffer(chanPtr->bufSize);
- }
+ if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+ statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
+ }
- outBufPtr = chanPtr->curOutPtr;
+ outBufPtr = statePtr->curOutPtr;
- destCopied = outBufPtr->bufLength - outBufPtr->nextAdded;
- if (destCopied > srcLen) {
- destCopied = srcLen;
- }
-
- destPtr = outBufPtr->buf + outBufPtr->nextAdded;
- switch (chanPtr->outputTranslation) {
- case TCL_TRANSLATE_LF:
- srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
- break;
- case TCL_TRANSLATE_CR:
- srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
- for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
- if (*dPtr == '\n') {
- *dPtr = '\r';
- }
- }
- break;
- case TCL_TRANSLATE_CRLF:
- for (srcCopied = 0, dPtr = destPtr, sPtr = src;
- dPtr < destPtr + destCopied;
- dPtr++, sPtr++, srcCopied++) {
- if (*sPtr == '\n') {
- if (crsent) {
- *dPtr = '\n';
- crsent = 0;
- } else {
- *dPtr = '\r';
- crsent = 1;
- sPtr--, srcCopied--;
- }
- } else {
- *dPtr = *sPtr;
- }
- }
- break;
- case TCL_TRANSLATE_AUTO:
- panic("Tcl_Write: AUTO output translation mode not supported");
- default:
- panic("Tcl_Write: unknown output translation mode");
- }
+ destCopied = outBufPtr->bufLength - outBufPtr->nextAdded;
+ if (destCopied > srcLen) {
+ destCopied = srcLen;
+ }
+
+ destPtr = outBufPtr->buf + outBufPtr->nextAdded;
+ switch (statePtr->outputTranslation) {
+ case TCL_TRANSLATE_LF:
+ srcCopied = destCopied;
+ memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+ break;
+ case TCL_TRANSLATE_CR:
+ srcCopied = destCopied;
+ memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+ for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
+ if (*dPtr == '\n') {
+ *dPtr = '\r';
+ }
+ }
+ break;
+ case TCL_TRANSLATE_CRLF:
+ for (srcCopied = 0, dPtr = destPtr, sPtr = src;
+ dPtr < destPtr + destCopied;
+ dPtr++, sPtr++, srcCopied++) {
+ if (*sPtr == '\n') {
+ if (crsent) {
+ *dPtr = '\n';
+ crsent = 0;
+ } else {
+ *dPtr = '\r';
+ crsent = 1;
+ sPtr--, srcCopied--;
+ }
+ } else {
+ *dPtr = *sPtr;
+ }
+ }
+ break;
+ case TCL_TRANSLATE_AUTO:
+ panic("Tcl_Write: AUTO output translation mode not supported");
+ default:
+ panic("Tcl_Write: unknown output translation mode");
+ }
- /*
- * The current buffer is ready for output if it is full, or if it
- * contains a newline and this channel is line-buffered, or if it
- * contains any output and this channel is unbuffered.
- */
+ /*
+ * The current buffer is ready for output if it is full, or if it
+ * contains a newline and this channel is line-buffered, or if it
+ * contains any output and this channel is unbuffered.
+ */
- outBufPtr->nextAdded += destCopied;
- if (!(chanPtr->flags & BUFFER_READY)) {
- if (outBufPtr->nextAdded == outBufPtr->bufLength) {
- chanPtr->flags |= BUFFER_READY;
- } else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
- for (sPtr = src, i = 0, foundNewline = 0;
+ outBufPtr->nextAdded += destCopied;
+ if (!(statePtr->flags & BUFFER_READY)) {
+ if (outBufPtr->nextAdded == outBufPtr->bufLength) {
+ statePtr->flags |= BUFFER_READY;
+ } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
+ for (sPtr = src, i = 0, foundNewline = 0;
(i < srcCopied) && (!foundNewline);
i++, sPtr++) {
- if (*sPtr == '\n') {
- foundNewline = 1;
- break;
- }
- }
- if (foundNewline) {
- chanPtr->flags |= BUFFER_READY;
- }
- } else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
- chanPtr->flags |= BUFFER_READY;
- }
- }
-
- totalDestCopied += srcCopied;
- src += srcCopied;
- srcLen -= srcCopied;
+ if (*sPtr == '\n') {
+ foundNewline = 1;
+ break;
+ }
+ }
+ if (foundNewline) {
+ statePtr->flags |= BUFFER_READY;
+ }
+ } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
+ statePtr->flags |= BUFFER_READY;
+ }
+ }
+
+ totalDestCopied += srcCopied;
+ src += srcCopied;
+ srcLen -= srcCopied;
- if (chanPtr->flags & BUFFER_READY) {
- if (FlushChannel(NULL, chanPtr, 0) != 0) {
- return -1;
- }
- }
+ if (statePtr->flags & BUFFER_READY) {
+ if (FlushChannel(NULL, chanPtr, 0) != 0) {
+ return -1;
+ }
+ }
} /* Closes "while" */
return totalDestCopied;
@@ -7435,7 +7806,7 @@ DoWrite(chanPtr, src, srcLen)
* CopyEventProc --
*
* This routine is invoked as a channel event handler for
- * the background copy operation. It is just a trivial wrapper
+ * the background copy operation. It is just a trivial wrapper
* around the CopyData routine.
*
* Results:
@@ -7476,31 +7847,35 @@ static void
StopCopy(csPtr)
CopyState *csPtr; /* State for bg copy to stop . */
{
+ ChannelState *inStatePtr, *outStatePtr;
int nonBlocking;
if (!csPtr) {
return;
}
+ inStatePtr = csPtr->readPtr->state;
+ outStatePtr = csPtr->writePtr->state;
+
/*
* Restore the old blocking mode and output buffering mode.
*/
nonBlocking = (csPtr->readFlags & CHANNEL_NONBLOCKING);
- if (nonBlocking != (csPtr->readPtr->flags & CHANNEL_NONBLOCKING)) {
+ if (nonBlocking != (inStatePtr->flags & CHANNEL_NONBLOCKING)) {
SetBlockMode(NULL, csPtr->readPtr,
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
}
- if (csPtr->writePtr != csPtr->writePtr) {
- if (nonBlocking != (csPtr->writePtr->flags & CHANNEL_NONBLOCKING)) {
+ if (csPtr->readPtr != csPtr->writePtr) {
+ nonBlocking = (csPtr->writeFlags & CHANNEL_NONBLOCKING);
+ if (nonBlocking != (outStatePtr->flags & CHANNEL_NONBLOCKING)) {
SetBlockMode(NULL, csPtr->writePtr,
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
}
}
- csPtr->writePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
- csPtr->writePtr->flags |=
+ outStatePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
+ outStatePtr->flags |=
csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
-
if (csPtr->cmdPtr) {
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->readPtr, CopyEventProc,
@@ -7509,16 +7884,62 @@ StopCopy(csPtr)
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr,
CopyEventProc, (ClientData)csPtr);
}
- Tcl_DecrRefCount(csPtr->cmdPtr);
+ Tcl_DecrRefCount(csPtr->cmdPtr);
}
- csPtr->readPtr->csPtr = NULL;
- csPtr->writePtr->csPtr = NULL;
+ inStatePtr->csPtr = NULL;
+ outStatePtr->csPtr = NULL;
ckfree((char*) csPtr);
}
/*
*----------------------------------------------------------------------
*
+ * StackSetBlockMode --
+ *
+ * This function sets the blocking mode for a channel, iterating
+ * through each channel in a stack and updates the state flags.
+ *
+ * Results:
+ * 0 if OK, result code from failed blockModeProc otherwise.
+ *
+ * Side effects:
+ * Modifies the blocking mode of the channel and possibly generates
+ * an error.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StackSetBlockMode(chanPtr, mode)
+ Channel *chanPtr; /* Channel to modify. */
+ int mode; /* One of TCL_MODE_BLOCKING or
+ * TCL_MODE_NONBLOCKING. */
+{
+ int result = 0;
+ Tcl_DriverBlockModeProc *blockModeProc;
+
+ /*
+ * Start at the top of the channel stack
+ */
+
+ chanPtr = chanPtr->state->topChanPtr;
+ while (chanPtr != (Channel *) NULL) {
+ blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
+ if (blockModeProc != NULL) {
+ result = (*blockModeProc) (chanPtr->instanceData, mode);
+ if (result != 0) {
+ Tcl_SetErrno(result);
+ return result;
+ }
+ }
+ chanPtr = chanPtr->downChanPtr;
+ }
+ return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
* SetBlockMode --
*
* This function sets the blocking mode for a channel and updates
@@ -7541,13 +7962,11 @@ SetBlockMode(interp, chanPtr, mode)
int mode; /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
+ ChannelState *statePtr = chanPtr->state; /* state info for channel */
int result = 0;
- if (chanPtr->typePtr->blockModeProc != NULL) {
- result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
- mode);
- }
+
+ result = StackSetBlockMode(chanPtr, mode);
if (result != 0) {
- Tcl_SetErrno(result);
if (interp != (Tcl_Interp *) NULL) {
Tcl_AppendResult(interp, "error setting blocking mode: ",
Tcl_PosixError(interp), (char *) NULL);
@@ -7555,9 +7974,9 @@ SetBlockMode(interp, chanPtr, mode)
return TCL_ERROR;
}
if (mode == TCL_MODE_BLOCKING) {
- chanPtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
+ statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
} else {
- chanPtr->flags |= CHANNEL_NONBLOCKING;
+ statePtr->flags |= CHANNEL_NONBLOCKING;
}
return TCL_OK;
}
@@ -7608,23 +8027,23 @@ Tcl_GetChannelNamesEx(interp, pattern)
Tcl_Interp *interp; /* Interp for error reporting. */
char *pattern; /* pattern to filter on. */
{
- Channel *chanPtr;
+ ChannelState *statePtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
char *name;
Tcl_Obj *resultPtr;
resultPtr = Tcl_GetObjResult(interp);
- for (chanPtr = tsdPtr->firstChanPtr;
- chanPtr != NULL;
- chanPtr = chanPtr->nextChanPtr) {
- if (chanPtr == (Channel *) tsdPtr->stdinChannel) {
+ for (statePtr = tsdPtr->firstCSPtr;
+ statePtr != NULL;
+ statePtr = statePtr->nextCSPtr) {
+ if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
name = "stdin";
- } else if (chanPtr == (Channel *) tsdPtr->stdoutChannel) {
+ } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
name = "stdout";
- } else if (chanPtr == (Channel *) tsdPtr->stderrChannel) {
+ } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
name = "stderr";
} else {
- name = chanPtr->channelName;
+ name = statePtr->channelName;
}
if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) &&
(Tcl_ListObjAppendElement(interp, resultPtr,
@@ -7634,3 +8053,462 @@ Tcl_GetChannelNamesEx(interp, pattern)
}
return TCL_OK;
}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelRegistered --
+ *
+ * Checks whether the channel is associated with the interp.
+ * See also Tcl_RegisterChannel and Tcl_UnregisterChannel.
+ *
+ * Results:
+ * 0 if the channel is not registered in the interpreter, 1 else.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelRegistered (interp, chan)
+ Tcl_Interp* interp; /* The interp to query of the channel */
+ Tcl_Channel chan; /* The channel to check */
+{
+ Tcl_HashTable *hTblPtr; /* Hash table of channels. */
+ Tcl_HashEntry *hPtr; /* Search variable. */
+ Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of the real channel. */
+
+ /*
+ * Always check bottom-most channel in the stack. This is the one
+ * that gets registered.
+ */
+ chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ statePtr = chanPtr->state;
+
+ hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+ if (hTblPtr == (Tcl_HashTable *) NULL) {
+ return 0;
+ }
+ hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
+ if (hPtr == (Tcl_HashEntry *) NULL) {
+ return 0;
+ }
+ if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelShared --
+ *
+ * Checks whether the channel is shared by multiple interpreters.
+ *
+ * Results:
+ * A boolean value (0 = Not shared, 1 = Shared).
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelShared (chan)
+ Tcl_Channel chan; /* The channel to query */
+{
+ ChannelState *statePtr = ((Channel *) chan)->state;
+ /* State of real channel structure. */
+
+ return ((statePtr->refCount > 1) ? 1 : 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelExisting --
+ *
+ * Checks whether a channel of the given name exists in the
+ * (thread)-global list of all channels.
+ * See Tcl_GetChannelNamesEx for function exposed at the Tcl level.
+ *
+ * Results:
+ * A boolean value (0 = Does not exist, 1 = Does exist).
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelExisting(chanName)
+ CONST char* chanName; /* The name of the channel to look for. */
+{
+ ChannelState *statePtr;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ char *name;
+ int chanNameLen;
+
+ chanNameLen = strlen(chanName);
+ for (statePtr = tsdPtr->firstCSPtr;
+ statePtr != NULL;
+ statePtr = statePtr->nextCSPtr) {
+ if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
+ name = "stdin";
+ } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
+ name = "stdout";
+ } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
+ name = "stderr";
+ } else {
+ name = statePtr->channelName;
+ }
+
+ if ((*chanName == *name) &&
+ (memcmp(name, chanName, (size_t) chanNameLen) == 0)) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelName --
+ *
+ * Return the name of the channel type.
+ *
+ * Results:
+ * A pointer the name of the channel type.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+char *
+Tcl_ChannelName(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->typeName);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelVersion --
+ *
+ * Return the of version of the channel type.
+ *
+ * Results:
+ * TCL_CHANNEL_VERSION_2 or TCL_CHANNEL_VERSION_1.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_ChannelTypeVersion
+Tcl_ChannelVersion(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
+ return TCL_CHANNEL_VERSION_2;
+ } else {
+ /*
+ * In <v2 channel versions, the version field is occupied
+ * by the Tcl_DriverBlockModeProc
+ */
+ return TCL_CHANNEL_VERSION_1;
+ }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelBlockModeProc --
+ *
+ * Return the Tcl_DriverBlockModeProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverBlockModeProc *
+Tcl_ChannelBlockModeProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
+ return (chanTypePtr->blockModeProc);
+ } else {
+ return (Tcl_DriverBlockModeProc *) (chanTypePtr->version);
+ }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelCloseProc --
+ *
+ * Return the Tcl_DriverCloseProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverCloseProc *
+Tcl_ChannelCloseProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->closeProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelClose2Proc --
+ *
+ * Return the Tcl_DriverClose2Proc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverClose2Proc *
+Tcl_ChannelClose2Proc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->close2Proc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelInputProc --
+ *
+ * Return the Tcl_DriverInputProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverInputProc *
+Tcl_ChannelInputProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->inputProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelOutputProc --
+ *
+ * Return the Tcl_DriverOutputProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverOutputProc *
+Tcl_ChannelOutputProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->outputProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelSeekProc --
+ *
+ * Return the Tcl_DriverSeekProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverSeekProc *
+Tcl_ChannelSeekProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->seekProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelSetOptionProc --
+ *
+ * Return the Tcl_DriverSetOptionProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverSetOptionProc *
+Tcl_ChannelSetOptionProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->setOptionProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelGetOptionProc --
+ *
+ * Return the Tcl_DriverGetOptionProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverGetOptionProc *
+Tcl_ChannelGetOptionProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->getOptionProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelWatchProc --
+ *
+ * Return the Tcl_DriverWatchProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverWatchProc *
+Tcl_ChannelWatchProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->watchProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelGetHandleProc --
+ *
+ * Return the Tcl_DriverGetHandleProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverGetHandleProc *
+Tcl_ChannelGetHandleProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->getHandleProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelFlushProc --
+ *
+ * Return the Tcl_DriverFlushProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverFlushProc *
+Tcl_ChannelFlushProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->flushProc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelHandlerProc --
+ *
+ * Return the Tcl_DriverHandlerProc of the channel type.
+ *
+ * Results:
+ * A pointer to the proc.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverHandlerProc *
+Tcl_ChannelHandlerProc(chanTypePtr)
+ Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+{
+ return (chanTypePtr->handlerProc);
+}