summaryrefslogtreecommitdiffstats
path: root/generic/tclIO.c
diff options
context:
space:
mode:
authordkf <donal.k.fellows@manchester.ac.uk>2005-10-31 15:59:41 (GMT)
committerdkf <donal.k.fellows@manchester.ac.uk>2005-10-31 15:59:41 (GMT)
commit0db677b1ac70da5aa3d1bd0bd38555940c801519 (patch)
tree5c8dfe0a555dc09dfc5a26660b9481223d7694fc /generic/tclIO.c
parentf0c90cb3e57992ace7caa6e80973c7c5c9812ceb (diff)
downloadtcl-0db677b1ac70da5aa3d1bd0bd38555940c801519.zip
tcl-0db677b1ac70da5aa3d1bd0bd38555940c801519.tar.gz
tcl-0db677b1ac70da5aa3d1bd0bd38555940c801519.tar.bz2
Convert to using ANSI decls/definitions and using the (ANSI) assumption that NULL can be
cast to any pointer type transparently.
Diffstat (limited to 'generic/tclIO.c')
-rw-r--r--generic/tclIO.c2288
1 files changed, 1126 insertions, 1162 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 7291b1c..a771ac0 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -7,10 +7,10 @@
* Copyright (c) 1998-2000 Ajuba Solutions
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
*
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclIO.c,v 1.98 2005/10/14 17:33:18 vasiljevic Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.99 2005/10/31 15:59:41 dkf Exp $
*/
#include "tclInt.h"
@@ -19,7 +19,7 @@
/*
* All static variables used in this file are collected into a single instance
- * of the following structure. For multi-threaded implementations, there is
+ * of the following structure. For multi-threaded implementations, there is
* one instance of this structure for each thread.
*
* Notice that different structures with the same name appear in other files.
@@ -28,28 +28,25 @@
typedef struct ThreadSpecificData {
NextChannelHandler *nestedHandlerPtr;
- /* This variable holds the list of
- * nested ChannelHandlerEventProc
- * invocations. */
- ChannelState *firstCSPtr; /* List of all channels currently
- * open, indexed by ChannelState, as
- * only one ChannelState exists per
- * set of stacked channels. */
+ /* This variable holds the list of nested
+ * ChannelHandlerEventProc invocations. */
+ ChannelState *firstCSPtr; /* List of all channels currently open,
+ * indexed by ChannelState, as only one
+ * ChannelState exists per set of stacked
+ * channels. */
#ifdef oldcode
- int channelExitHandlerCreated; /* Has a channel exit handler been
- * created yet? */
- int channelEventSourceCreated; /* Has the channel event source been
- * created and registered with the
- * notifier? */
+ int channelExitHandlerCreated;
+ /* Has a channel exit handler been created
+ * yet? */
+ int channelEventSourceCreated;
+ /* Has the channel event source been created
+ * and registered with the notifier? */
#endif
- Tcl_Channel stdinChannel; /* Static variable for the stdin
- * channel. */
+ Tcl_Channel stdinChannel; /* Static variable for the stdin channel. */
int stdinInitialized;
- Tcl_Channel stdoutChannel; /* Static variable for the stdout
- * channel. */
+ Tcl_Channel stdoutChannel; /* Static variable for the stdout channel. */
int stdoutInitialized;
- Tcl_Channel stderrChannel; /* Static variable for the stderr
- * channel. */
+ Tcl_Channel stderrChannel; /* Static variable for the stderr channel. */
int stderrInitialized;
} ThreadSpecificData;
@@ -59,89 +56,73 @@ static Tcl_ThreadDataKey dataKey;
* Static functions in this file:
*/
-static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length));
-static void ChannelTimerProc _ANSI_ARGS_((
- ClientData clientData));
-static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr,
- int direction));
-static int CheckFlush _ANSI_ARGS_((Channel *chanPtr,
- ChannelBuffer *bufPtr, int newlineFlag));
-static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
- ChannelState *statePtr));
-static void CheckForStdChannelsBeingClosed _ANSI_ARGS_((
- Tcl_Channel chan));
-static void CleanupChannelHandlers _ANSI_ARGS_((
- Tcl_Interp *interp, Channel *chanPtr));
-static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int errorCode));
-static void CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr,
- Tcl_Encoding encoding));
-static int CopyAndTranslateBuffer _ANSI_ARGS_((
- ChannelState *statePtr, char *result, int space));
-static int CopyBuffer _ANSI_ARGS_((Channel *chanPtr,
- char *result, int space));
-static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
-static void CopyEventProc _ANSI_ARGS_((ClientData clientData,
- int mask));
-static void CreateScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mask, Tcl_Obj *scriptPtr));
-static void DeleteChannelTable _ANSI_ARGS_((
- ClientData clientData, Tcl_Interp *interp));
-static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mask));
-static int DetachChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Channel chan));
-static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr,
- int discardSavedBuffers));
-static void DiscardOutputQueued _ANSI_ARGS_((
- ChannelState *chanPtr));
-static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
- int slen));
-static int DoWrite _ANSI_ARGS_((Channel *chanPtr, CONST char *src,
- int srcLen));
-static int DoReadChars _ANSI_ARGS_((Channel *chan,
- Tcl_Obj *objPtr, int toRead, int appendFlag));
-static int DoWriteChars _ANSI_ARGS_((Channel *chan,
- CONST char *src, int len));
-static int FilterInputBytes _ANSI_ARGS_((Channel *chanPtr,
- GetsState *statePtr));
-static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int calledFromAsyncFlush));
-static Tcl_HashTable * GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
-static int GetInput _ANSI_ARGS_((Channel *chanPtr));
-static int HaveVersion _ANSI_ARGS_((Tcl_ChannelType *typePtr,
- Tcl_ChannelTypeVersion minimumVersion));
-static void PeekAhead _ANSI_ARGS_((Channel *chanPtr,
- char **dstEndPtr, GetsState *gsPtr));
-static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr,
- Tcl_Obj *objPtr, int charsLeft, int *offsetPtr));
-static int ReadChars _ANSI_ARGS_((ChannelState *statePtr,
- Tcl_Obj *objPtr, int charsLeft,
- int *offsetPtr, int *factorPtr));
-static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr,
- ChannelBuffer *bufPtr, int mustDiscard));
-static int StackSetBlockMode _ANSI_ARGS_((Channel *chanPtr,
- int mode));
-static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
- Channel *chanPtr, int mode));
-static void StopCopy _ANSI_ARGS_((CopyState *csPtr));
-static int TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr,
- char *dst, CONST char *src,
- int *dstLenPtr, int *srcLenPtr));
-static int TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr,
- char *dst, CONST char *src,
- int *dstLenPtr, int *srcLenPtr));
-static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
-static int WriteBytes _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
-static int WriteChars _ANSI_ARGS_((Channel *chanPtr,
- CONST char *src, int srcLen));
-static Tcl_Obj* FixLevelCode _ANSI_ARGS_ ((Tcl_Obj* msg));
-
-
-static void SpliceChannel _ANSI_ARGS_ ((Tcl_Channel chan));
-static void CutChannel _ANSI_ARGS_ ((Tcl_Channel chan));
-
+static ChannelBuffer * AllocChannelBuffer(int length);
+static void ChannelTimerProc(ClientData clientData);
+static int CheckChannelErrors(ChannelState *statePtr,
+ int direction);
+static int CheckFlush(Channel *chanPtr, ChannelBuffer *bufPtr,
+ int newlineFlag);
+static int CheckForDeadChannel(Tcl_Interp *interp,
+ ChannelState *statePtr);
+static void CheckForStdChannelsBeingClosed(Tcl_Channel chan);
+static void CleanupChannelHandlers(Tcl_Interp *interp,
+ Channel *chanPtr);
+static int CloseChannel(Tcl_Interp *interp, Channel *chanPtr,
+ int errorCode);
+static void CommonGetsCleanup(Channel *chanPtr,
+ Tcl_Encoding encoding);
+static int CopyAndTranslateBuffer(ChannelState *statePtr,
+ char *result, int space);
+static int CopyBuffer(Channel *chanPtr, char *result, int space);
+static int CopyData(CopyState *csPtr, int mask);
+static void CopyEventProc(ClientData clientData, int mask);
+static void CreateScriptRecord(Tcl_Interp *interp,
+ Channel *chanPtr, int mask, Tcl_Obj *scriptPtr);
+static void DeleteChannelTable(ClientData clientData,
+ Tcl_Interp *interp);
+static void DeleteScriptRecord(Tcl_Interp *interp,
+ Channel *chanPtr, int mask);
+static int DetachChannel(Tcl_Interp *interp, Tcl_Channel chan);
+static void DiscardInputQueued(ChannelState *statePtr,
+ int discardSavedBuffers);
+static void DiscardOutputQueued(ChannelState *chanPtr);
+static int DoRead(Channel *chanPtr, char *srcPtr, int slen);
+static int DoWrite(Channel *chanPtr, CONST char *src, int srcLen);
+static int DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
+ int appendFlag);
+static int DoWriteChars(Channel *chan, CONST char *src, int len);
+static int FilterInputBytes(Channel *chanPtr,
+ GetsState *statePtr);
+static int FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
+ int calledFromAsyncFlush);
+static Tcl_HashTable * GetChannelTable(Tcl_Interp *interp);
+static int GetInput(Channel *chanPtr);
+static int HaveVersion(Tcl_ChannelType *typePtr,
+ Tcl_ChannelTypeVersion minimumVersion);
+static void PeekAhead(Channel *chanPtr, char **dstEndPtr,
+ GetsState *gsPtr);
+static int ReadBytes(ChannelState *statePtr, Tcl_Obj *objPtr,
+ int charsLeft, int *offsetPtr);
+static int ReadChars(ChannelState *statePtr, Tcl_Obj *objPtr,
+ int charsLeft, int *offsetPtr, int *factorPtr);
+static void RecycleBuffer(ChannelState *statePtr,
+ ChannelBuffer *bufPtr, int mustDiscard);
+static int StackSetBlockMode(Channel *chanPtr, int mode);
+static int SetBlockMode(Tcl_Interp *interp, Channel *chanPtr,
+ int mode);
+static void StopCopy(CopyState *csPtr);
+static int TranslateInputEOL(ChannelState *statePtr, char *dst,
+ CONST char *src, int *dstLenPtr, int *srcLenPtr);
+static int TranslateOutputEOL(ChannelState *statePtr, char *dst,
+ CONST char *src, int *dstLenPtr, int *srcLenPtr);
+static void UpdateInterest(Channel *chanPtr);
+static int WriteBytes(Channel *chanPtr, CONST char *src,
+ int srcLen);
+static int WriteChars(Channel *chanPtr, CONST char *src,
+ int srcLen);
+static Tcl_Obj * FixLevelCode(Tcl_Obj* msg);
+static void SpliceChannel(Tcl_Channel chan);
+static void CutChannel(Tcl_Channel chan);
/*
*---------------------------------------------------------------------------
@@ -161,7 +142,7 @@ static void CutChannel _ANSI_ARGS_ ((Tcl_Channel chan));
*/
void
-TclInitIOSubsystem()
+TclInitIOSubsystem(void)
{
/*
* By fetching thread local storage we take care of allocating it for each
@@ -191,14 +172,14 @@ TclInitIOSubsystem()
/* ARGSUSED */
void
-TclFinalizeIOSubsystem()
+TclFinalizeIOSubsystem(void)
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- Channel *chanPtr; /* Iterates over open channels. */
- ChannelState *nextCSPtr; /* Iterates over open channels. */
- ChannelState *statePtr; /* state of channel stack */
+ Channel *chanPtr; /* Iterates over open channels. */
+ ChannelState *nextCSPtr; /* Iterates over open channels. */
+ ChannelState *statePtr; /* state of channel stack */
- for (statePtr = tsdPtr->firstCSPtr; statePtr != (ChannelState *) NULL;
+ for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL;
statePtr = nextCSPtr) {
chanPtr = statePtr->topChanPtr;
nextCSPtr = statePtr->nextCSPtr;
@@ -229,7 +210,7 @@ TclFinalizeIOSubsystem()
* will close the channel when it gets destroyed.
*/
- (void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ (void) Tcl_Close(NULL, (Tcl_Channel) chanPtr);
} else {
/*
@@ -244,11 +225,9 @@ TclFinalizeIOSubsystem()
*/
if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
- (chanPtr->typePtr->closeProc)(chanPtr->instanceData,
- (Tcl_Interp *) NULL);
+ (chanPtr->typePtr->closeProc)(chanPtr->instanceData, NULL);
} else {
- (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
- (Tcl_Interp *) NULL, 0);
+ (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, NULL, 0);
}
/*
@@ -258,7 +237,7 @@ TclFinalizeIOSubsystem()
* on it.
*/
- chanPtr->instanceData = (ClientData) NULL;
+ chanPtr->instanceData = NULL;
statePtr->flags |= CHANNEL_DEAD;
}
}
@@ -283,9 +262,9 @@ TclFinalizeIOSubsystem()
*/
void
-Tcl_SetStdChannel(channel, type)
- Tcl_Channel channel;
- int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+Tcl_SetStdChannel(
+ Tcl_Channel channel,
+ int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
switch (type) {
@@ -321,8 +300,8 @@ Tcl_SetStdChannel(channel, type)
*/
Tcl_Channel
-Tcl_GetStdChannel(type)
- int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+Tcl_GetStdChannel(
+ int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
{
Tcl_Channel channel = NULL;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -347,9 +326,8 @@ Tcl_GetStdChannel(type)
* standard input.
*/
- if (tsdPtr->stdinChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stdinChannel);
+ if (tsdPtr->stdinChannel != NULL) {
+ (void) Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
}
}
channel = tsdPtr->stdinChannel;
@@ -358,9 +336,8 @@ Tcl_GetStdChannel(type)
if (!tsdPtr->stdoutInitialized) {
tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
tsdPtr->stdoutInitialized = 1;
- if (tsdPtr->stdoutChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stdoutChannel);
+ if (tsdPtr->stdoutChannel != NULL) {
+ (void) Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
}
}
channel = tsdPtr->stdoutChannel;
@@ -369,9 +346,8 @@ Tcl_GetStdChannel(type)
if (!tsdPtr->stderrInitialized) {
tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
tsdPtr->stderrInitialized = 1;
- if (tsdPtr->stderrChannel != (Tcl_Channel) NULL) {
- (void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
- tsdPtr->stderrChannel);
+ if (tsdPtr->stderrChannel != NULL) {
+ (void) Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
}
}
channel = tsdPtr->stderrChannel;
@@ -399,12 +375,12 @@ Tcl_GetStdChannel(type)
*/
void
-Tcl_CreateCloseHandler(chan, proc, clientData)
- Tcl_Channel chan; /* The channel for which to create the close
+Tcl_CreateCloseHandler(
+ Tcl_Channel chan, /* The channel for which to create the close
* callback. */
- Tcl_CloseProc *proc; /* The callback routine to call when the
+ Tcl_CloseProc *proc, /* The callback routine to call when the
* channel will be closed. */
- ClientData clientData; /* Arbitrary data to pass to the close
+ ClientData clientData) /* Arbitrary data to pass to the close
* callback. */
{
ChannelState *statePtr;
@@ -412,7 +388,7 @@ Tcl_CreateCloseHandler(chan, proc, clientData)
statePtr = ((Channel *) chan)->state;
- cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
+ cbPtr = (CloseCallback *) ckalloc(sizeof(CloseCallback));
cbPtr->proc = proc;
cbPtr->clientData = clientData;
@@ -439,23 +415,22 @@ Tcl_CreateCloseHandler(chan, proc, clientData)
*/
void
-Tcl_DeleteCloseHandler(chan, proc, clientData)
- Tcl_Channel chan; /* The channel for which to cancel the close
+Tcl_DeleteCloseHandler(
+ Tcl_Channel chan, /* The channel for which to cancel the close
* callback. */
- Tcl_CloseProc *proc; /* The procedure for the callback to
+ Tcl_CloseProc *proc, /* The procedure for the callback to
* remove. */
- ClientData clientData; /* The callback data for the callback to
+ ClientData clientData) /* The callback data for the callback to
* remove. */
{
ChannelState *statePtr;
CloseCallback *cbPtr, *cbPrevPtr;
statePtr = ((Channel *) chan)->state;
- for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
- cbPtr != (CloseCallback *) NULL;
- cbPtr = cbPtr->nextPtr) {
+ for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = NULL;
+ cbPtr != NULL; cbPtr = cbPtr->nextPtr) {
if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
- if (cbPrevPtr == (CloseCallback *) NULL) {
+ if (cbPrevPtr == NULL) {
statePtr->closeCbPtr = cbPtr->nextPtr;
}
ckfree((char *) cbPtr);
@@ -486,15 +461,15 @@ Tcl_DeleteCloseHandler(chan, proc, clientData)
*/
static Tcl_HashTable *
-GetChannelTable(interp)
- Tcl_Interp *interp;
+GetChannelTable(
+ Tcl_Interp *interp)
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_Channel stdinChan, stdoutChan, stderrChan;
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
- hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable));
+ if (hTblPtr == NULL) {
+ hTblPtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
(void) Tcl_SetAssocData(interp, "tclIO",
@@ -545,9 +520,9 @@ GetChannelTable(interp)
*/
static void
-DeleteChannelTable(clientData, interp)
- ClientData clientData; /* The per-interpreter data structure. */
- Tcl_Interp *interp; /* The interpreter being deleted. */
+DeleteChannelTable(
+ ClientData clientData, /* The per-interpreter data structure. */
+ Tcl_Interp *interp) /* The interpreter being deleted. */
{
Tcl_HashTable *hTblPtr; /* The hash table. */
Tcl_HashSearch hSearch; /* Search variable. */
@@ -565,10 +540,8 @@ DeleteChannelTable(clientData, interp)
*/
hTblPtr = (Tcl_HashTable *) clientData;
- for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
- hPtr != (Tcl_HashEntry *) NULL;
+ for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
-
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
statePtr = chanPtr->state;
@@ -576,13 +549,11 @@ DeleteChannelTable(clientData, interp)
* Remove any fileevents registered in this interpreter.
*/
- for (sPtr = statePtr->scriptRecordPtr,
- prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
+ for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+ sPtr != NULL; sPtr = nextPtr) {
nextPtr = sPtr->nextPtr;
if (sPtr->interp == interp) {
- if (prevPtr == (EventScriptRecord *) NULL) {
+ if (prevPtr == NULL) {
statePtr->scriptRecordPtr = nextPtr;
} else {
prevPtr->nextPtr = nextPtr;
@@ -640,8 +611,8 @@ DeleteChannelTable(clientData, interp)
*/
static void
-CheckForStdChannelsBeingClosed(chan)
- Tcl_Channel chan;
+CheckForStdChannelsBeingClosed(
+ Tcl_Channel chan)
{
ChannelState *statePtr = ((Channel *) chan)->state;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -674,9 +645,9 @@ CheckForStdChannelsBeingClosed(chan)
*
* Tcl_IsStandardChannel --
*
- * Test if the given channel is a standard channel. No attempt
- * is made to check if the channel or the standard channels
- * are initialized or otherwise valid.
+ * Test if the given channel is a standard channel. No attempt is made to
+ * check if the channel or the standard channels are initialized or
+ * otherwise valid.
*
* Results:
* Returns 1 if true, 0 if false.
@@ -688,8 +659,8 @@ CheckForStdChannelsBeingClosed(chan)
*/
int
-Tcl_IsStandardChannel(chan)
- Tcl_Channel chan; /* Channel to check. */
+Tcl_IsStandardChannel(
+ Tcl_Channel chan) /* Channel to check. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -721,9 +692,9 @@ Tcl_IsStandardChannel(chan)
*/
void
-Tcl_RegisterChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which to add the channel. */
- Tcl_Channel chan; /* The channel to add to this interpreter
+Tcl_RegisterChannel(
+ Tcl_Interp *interp, /* Interpreter in which to add the channel. */
+ Tcl_Channel chan) /* The channel to add to this interpreter
* channel table. */
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
@@ -733,7 +704,7 @@ Tcl_RegisterChannel(interp, chan)
ChannelState *statePtr; /* State of the actual channel. */
/*
- * Always (un)register bottom-most channel in the stack. This makes
+ * Always (un)register bottom-most channel in the stack. This makes
* management of the channel list easier because no manipulation is
* necessary during (un)stack operation.
*/
@@ -741,15 +712,15 @@ Tcl_RegisterChannel(interp, chan)
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- if (statePtr->channelName == (CONST char *) NULL) {
+ if (statePtr->channelName == NULL) {
Tcl_Panic("Tcl_RegisterChannel: channel without name");
}
- if (interp != (Tcl_Interp *) NULL) {
+ if (interp != NULL) {
hTblPtr = GetChannelTable(interp);
hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new);
if (new == 0) {
if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
- return;
+ return;
}
Tcl_Panic("Tcl_RegisterChannel: duplicate channel names");
@@ -766,7 +737,7 @@ Tcl_RegisterChannel(interp, chan)
*
* Deletes the hash entry for a channel associated with an interpreter.
* If the interpreter given as argument is NULL, it only decrements the
- * reference count. (This all happens in the Tcl_DetachChannel helper
+ * reference count. (This all happens in the Tcl_DetachChannel helper
* function).
*
* Finally, if the reference count of the channel drops to zero, it is
@@ -786,18 +757,18 @@ Tcl_RegisterChannel(interp, chan)
*/
int
-Tcl_UnregisterChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+Tcl_UnregisterChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
ChannelState *statePtr; /* State of the real channel. */
statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
if (statePtr->flags & CHANNEL_INCLOSE) {
- if (interp != (Tcl_Interp *) NULL) {
+ if (interp != NULL) {
Tcl_AppendResult(interp, "Illegal recursive call to close ",
- "through close-handler of channel", (char *) NULL);
+ "through close-handler of channel", NULL);
}
return TCL_ERROR;
}
@@ -823,7 +794,6 @@ Tcl_UnregisterChannel(interp, chan)
*/
if (statePtr->refCount <= 0) {
-
/*
* Ensure that if there is another buffer, it gets flushed whether or
* not we are doing a background flush.
@@ -861,9 +831,9 @@ Tcl_UnregisterChannel(interp, chan)
*
* Deletes the hash entry for a channel associated with an interpreter.
* If the interpreter given as argument is NULL, it only decrements the
- * reference count. Even if the ref count drops to zero, the channel is
- * NOT closed or cleaned up. This allows a channel to be detached from
- * an interpreter and left in the same state it was in when it was
+ * reference count. Even if the ref count drops to zero, the channel is
+ * NOT closed or cleaned up. This allows a channel to be detached from an
+ * interpreter and left in the same state it was in when it was
* originally returned by 'Tcl_OpenFileChannel', for example.
*
* This function cannot be used on the standard channels, and will return
@@ -871,15 +841,15 @@ Tcl_UnregisterChannel(interp, chan)
*
* This function should only be necessary for special purposes in which
* you need to generate a pristine channel from one that has already been
- * used. All ordinary purposes will almost always want to use
+ * used. All ordinary purposes will almost always want to use
* Tcl_UnregisterChannel instead.
*
* Provided the channel is not attached to any other interpreter, it can
* then be closed with Tcl_Close, rather than with Tcl_UnregisterChannel.
*
* Results:
- * A standard Tcl result. If the channel is not currently registered
- * with the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ * A standard Tcl result. If the channel is not currently registered with
+ * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
* However no error messages are left in the interp's result.
*
* Side effects:
@@ -889,9 +859,9 @@ Tcl_UnregisterChannel(interp, chan)
*/
int
-Tcl_DetachChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+Tcl_DetachChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
if (Tcl_IsStandardChannel(chan)) {
return TCL_ERROR;
@@ -907,14 +877,14 @@ Tcl_DetachChannel(interp, chan)
*
* Deletes the hash entry for a channel associated with an interpreter.
* If the interpreter given as argument is NULL, it only decrements the
- * reference count. Even if the ref count drops to zero, the channel is
- * NOT closed or cleaned up. This allows a channel to be detached from
- * an interpreter and left in the same state it was in when it was
+ * reference count. Even if the ref count drops to zero, the channel is
+ * NOT closed or cleaned up. This allows a channel to be detached from an
+ * interpreter and left in the same state it was in when it was
* originally returned by 'Tcl_OpenFileChannel', for example.
*
* Results:
- * A standard Tcl result. If the channel is not currently registered
- * with the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ * A standard Tcl result. If the channel is not currently registered with
+ * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
* However no error messages are left in the interp's result.
*
* Side effects:
@@ -924,9 +894,9 @@ Tcl_DetachChannel(interp, chan)
*/
static int
-DetachChannel(interp, chan)
- Tcl_Interp *interp; /* Interpreter in which channel is defined. */
- Tcl_Channel chan; /* Channel to delete. */
+DetachChannel(
+ Tcl_Interp *interp, /* Interpreter in which channel is defined. */
+ Tcl_Channel chan) /* Channel to delete. */
{
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
@@ -934,7 +904,7 @@ DetachChannel(interp, chan)
ChannelState *statePtr; /* State of the real channel. */
/*
- * Always (un)register bottom-most channel in the stack. This makes
+ * Always (un)register bottom-most channel in the stack. This makes
* management of the channel list easier because no manipulation is
* necessary during (un)stack operation.
*/
@@ -942,13 +912,13 @@ DetachChannel(interp, chan)
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- if (interp != (Tcl_Interp *) NULL) {
+ if (interp != NULL) {
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
+ if (hTblPtr == NULL) {
return TCL_ERROR;
}
hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
- if (hPtr == (Tcl_HashEntry *) NULL) {
+ if (hPtr == NULL) {
return TCL_ERROR;
}
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
@@ -983,7 +953,7 @@ DetachChannel(interp, chan)
*
* Results:
* A Tcl_Channel or NULL on failure. If failed, interp's result object
- * contains an error message. *modePtr is filled with the modes in which
+ * contains an error message. *modePtr is filled with the modes in which
* the channel was opened.
*
* Side effects:
@@ -993,11 +963,11 @@ DetachChannel(interp, chan)
*/
Tcl_Channel
-Tcl_GetChannel(interp, chanName, modePtr)
- Tcl_Interp *interp; /* Interpreter in which to find or create the
+Tcl_GetChannel(
+ Tcl_Interp *interp, /* Interpreter in which to find or create the
* channel. */
- CONST char *chanName; /* The name of the channel. */
- int *modePtr; /* Where to store the mode in which the
+ CONST char *chanName, /* The name of the channel. */
+ int *modePtr) /* Where to store the mode in which the
* channel was opened? Will contain an ORed
* combination of TCL_READABLE and
* TCL_WRITABLE, if non-NULL. */
@@ -1008,10 +978,10 @@ Tcl_GetChannel(interp, chanName, modePtr)
CONST char *name; /* Translated name. */
/*
- * Substitute "stdin", etc. Note that even though we immediately find the
+ * Substitute "stdin", etc. Note that even though we immediately find the
* channel using Tcl_GetStdChannel, we still need to look it up in the
* specified interpreter to ensure that it is present in the channel
- * table. Otherwise, safe interpreters would always have access to the
+ * table. Otherwise, safe interpreters would always have access to the
* standard channels.
*/
@@ -1032,9 +1002,9 @@ Tcl_GetChannel(interp, chanName, modePtr)
hTblPtr = GetChannelTable(interp);
hPtr = Tcl_FindHashEntry(hTblPtr, name);
- if (hPtr == (Tcl_HashEntry *) NULL) {
- Tcl_AppendResult(interp, "can not find channel named \"",
- chanName, "\"", (char *) NULL);
+ if (hPtr == NULL) {
+ Tcl_AppendResult(interp, "can not find channel named \"", chanName,
+ "\"", NULL);
return NULL;
}
@@ -1070,11 +1040,11 @@ Tcl_GetChannel(interp, chanName, modePtr)
*/
Tcl_Channel
-Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
- Tcl_ChannelType *typePtr; /* The channel type record. */
- CONST char *chanName; /* Name of channel to record. */
- ClientData instanceData; /* Instance specific data. */
- int mask; /* TCL_READABLE & TCL_WRITABLE to indicate if
+Tcl_CreateChannel(
+ Tcl_ChannelType *typePtr, /* The channel type record. */
+ CONST char *chanName, /* Name of channel to record. */
+ ClientData instanceData, /* Instance specific data. */
+ int mask) /* TCL_READABLE & TCL_WRITABLE to indicate if
* the channel is readable, writable. */
{
Channel *chanPtr; /* The channel structure newly created. */
@@ -1100,8 +1070,8 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
* assignments to 0/NULL below.
*/
- chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
- statePtr = (ChannelState *) ckalloc((unsigned) sizeof(ChannelState));
+ chanPtr = (Channel *) ckalloc(sizeof(Channel));
+ statePtr = (ChannelState *) ckalloc(sizeof(ChannelState));
chanPtr->state = statePtr;
chanPtr->instanceData = instanceData;
@@ -1112,7 +1082,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
* information for the channel.
*/
- if (chanName != (char *) NULL) {
+ if (chanName != NULL) {
char *tmp = ckalloc((unsigned) (strlen(chanName) + 1));
statePtr->channelName = tmp;
strcpy(tmp, chanName);
@@ -1125,10 +1095,10 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
/*
* Set the channel to system default encoding.
*
- * Note the strange bit of protection taking place here. If the system
+ * Note the strange bit of protection taking place here. If the system
* encoding name is reported back as "binary", something weird is
- * happening. Tcl provides no "binary" encoding, so someone else has
- * provided one. We ignore it so as not to interfere with the "magic"
+ * happening. Tcl provides no "binary" encoding, so someone else has
+ * provided one. We ignore it so as not to interfere with the "magic"
* interpretation that Tcl_Channels give to the "-encoding binary" option.
*/
@@ -1137,10 +1107,10 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
if (strcmp(name, "binary") != 0) {
statePtr->encoding = Tcl_GetEncoding(NULL, name);
}
- statePtr->inputEncodingState = NULL;
- statePtr->inputEncodingFlags = TCL_ENCODING_START;
- statePtr->outputEncodingState = NULL;
- statePtr->outputEncodingFlags = TCL_ENCODING_START;
+ statePtr->inputEncodingState = NULL;
+ statePtr->inputEncodingFlags = TCL_ENCODING_START;
+ statePtr->outputEncodingState = NULL;
+ statePtr->outputEncodingFlags = TCL_ENCODING_START;
/*
* Set the channel up initially in AUTO input translation mode to accept
@@ -1157,16 +1127,16 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
statePtr->unreportedError = 0;
statePtr->refCount = 0;
- statePtr->closeCbPtr = (CloseCallback *) NULL;
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
- statePtr->outQueueHead = (ChannelBuffer *) NULL;
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
- statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
- statePtr->chPtr = (ChannelHandler *) NULL;
+ statePtr->closeCbPtr = NULL;
+ statePtr->curOutPtr = NULL;
+ statePtr->outQueueHead = NULL;
+ statePtr->outQueueTail = NULL;
+ statePtr->saveInBufPtr = NULL;
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
+ statePtr->chPtr = NULL;
statePtr->interestMask = 0;
- statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->scriptRecordPtr = NULL;
statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
statePtr->timer = NULL;
statePtr->csPtr = NULL;
@@ -1183,14 +1153,17 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
statePtr->topChanPtr = chanPtr;
statePtr->bottomChanPtr = chanPtr;
- chanPtr->downChanPtr = (Channel *) NULL;
- chanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ chanPtr->downChanPtr = NULL;
+ chanPtr->upChanPtr = NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
+
+ /*
+ * TIP #219, Tcl Channel Reflection API
+ */
- /* TIP #219, Tcl Channel Reflection API */
- statePtr->chanMsg = NULL;
- statePtr->unreportedMsg = NULL;
+ statePtr->chanMsg = NULL;
+ statePtr->unreportedMsg = NULL;
/*
* Link the channel into the list of all channels; create an on-exit
@@ -1201,7 +1174,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
*
* TIP #218.
* AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel
- * We need Tcl_SpliceChannel, for the threadAction calls. There is no
+ * We need Tcl_SpliceChannel, for the threadAction calls. There is no
* real reason to duplicate all of this.
* NOTE: All drivers using thread actions now have to perform their TSD
* manipulation only in their thread action proc. Doing it when
@@ -1209,8 +1182,8 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
* action activity and lead to damaged lists.
*/
- statePtr->nextCSPtr = (ChannelState *) NULL;
- SpliceChannel ((Tcl_Channel) chanPtr);
+ statePtr->nextCSPtr = NULL;
+ SpliceChannel((Tcl_Channel) chanPtr);
/*
* Install this channel in the first empty standard channel slot, if the
@@ -1219,15 +1192,15 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) {
Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN);
- Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
} else if ((tsdPtr->stdoutChannel == NULL) &&
(tsdPtr->stdoutInitialized == 1)) {
Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT);
- Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
} else if ((tsdPtr->stderrChannel == NULL) &&
(tsdPtr->stderrInitialized == 1)) {
Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR);
- Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
+ Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
}
return (Tcl_Channel) chanPtr;
}
@@ -1252,7 +1225,7 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
*
* Side effects:
* A new channel structure is allocated and linked below the existing
- * channel. The channel operations and client data of the existing channel
+ * channel. The channel operations and client data of the existing channel
* are copied down to the newly created channel, and the current channel
* has its operations replaced by the new typePtr.
*
@@ -1260,15 +1233,15 @@ Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
*/
Tcl_Channel
-Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
- Tcl_Interp *interp; /* The interpreter we are working in */
- Tcl_ChannelType *typePtr; /* The channel type record for the new
+Tcl_StackChannel(
+ Tcl_Interp *interp, /* The interpreter we are working in */
+ Tcl_ChannelType *typePtr, /* The channel type record for the new
* channel. */
- ClientData instanceData; /* Instance specific data for the new
+ ClientData instanceData, /* Instance specific data for the new
* channel. */
- int mask; /* TCL_READABLE & TCL_WRITABLE to indicate if
+ 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, *prevChanPtr;
@@ -1276,8 +1249,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
Tcl_DriverThreadActionProc *threadActionProc;
/*
- * Find the given channel (prevChan) in the list of all channels. If we don't find
- * it, then it was never registered correctly.
+ * Find the given channel (prevChan) in the list of all channels. If we do
+ * not find it, then it was never registered correctly.
*
* This operation should occur at the top of a channel stack.
*/
@@ -1291,7 +1264,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
if (statePtr == NULL) {
Tcl_AppendResult(interp, "couldn't find state for channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
return (Tcl_Channel) NULL;
}
@@ -1311,7 +1284,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) {
Tcl_AppendResult(interp,
"reading and writing both disallowed for channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
return (Tcl_Channel) NULL;
}
@@ -1326,12 +1299,12 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
CopyState *csPtr;
csPtr = statePtr->csPtr;
- statePtr->csPtr = (CopyState *) NULL;
+ statePtr->csPtr = NULL;
if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) {
statePtr->csPtr = csPtr;
Tcl_AppendResult(interp, "could not flush channel \"",
- Tcl_GetChannelName(prevChan), "\"", (char *) NULL);
+ Tcl_GetChannelName(prevChan), "\"", NULL);
return (Tcl_Channel) NULL;
}
@@ -1352,8 +1325,7 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
* they are going away.
*/
- if (((mask & TCL_READABLE) != 0) &&
- (statePtr->inQueueHead != (ChannelBuffer *) NULL)) {
+ if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) {
/*
* Remark: It is possible that the channel buffers contain data from
* some earlier push-backs.
@@ -1362,15 +1334,15 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
prevChanPtr->inQueueHead = statePtr->inQueueHead;
- if (prevChanPtr->inQueueTail == (ChannelBuffer *) NULL) {
+ if (prevChanPtr->inQueueTail == NULL) {
prevChanPtr->inQueueTail = statePtr->inQueueTail;
}
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
}
- chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
+ chanPtr = (Channel *) ckalloc(sizeof(Channel));
/*
* Save some of the current state into the new structure, reinitialize the
@@ -1383,9 +1355,9 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
chanPtr->instanceData = instanceData;
chanPtr->typePtr = typePtr;
chanPtr->downChanPtr = prevChanPtr;
- chanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ chanPtr->upChanPtr = NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
/*
* Place new block at the head of a possibly existing list of previously
@@ -1395,7 +1367,8 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
prevChanPtr->upChanPtr = chanPtr;
statePtr->topChanPtr = chanPtr;
- /* TIP #218, Channel Thread Actions.
+ /*
+ * TIP #218, Channel Thread Actions.
*
* We call the thread actions for the new channel directly. We _cannot_
* use SpliceChannel, because the (thread-)global list of all channels
@@ -1405,10 +1378,9 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
* time, mangling it.
*/
- threadActionProc = Tcl_ChannelThreadActionProc (chanPtr->typePtr);
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
if (threadActionProc != NULL) {
- (*threadActionProc) (chanPtr->instanceData,
- TCL_CHANNEL_THREAD_INSERT);
+ (*threadActionProc)(chanPtr->instanceData, TCL_CHANNEL_THREAD_INSERT);
}
return (Tcl_Channel) chanPtr;
@@ -1433,9 +1405,9 @@ Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan)
*/
int
-Tcl_UnstackChannel(interp, chan)
- Tcl_Interp *interp; /* The interpreter we are working in */
- Tcl_Channel chan; /* The channel to unstack */
+Tcl_UnstackChannel(
+ Tcl_Interp *interp, /* The interpreter we are working in */
+ Tcl_Channel chan) /* The channel to unstack */
{
Channel *chanPtr = (Channel *) chan;
ChannelState *statePtr = chanPtr->state;
@@ -1448,7 +1420,7 @@ Tcl_UnstackChannel(interp, chan)
chanPtr = statePtr->topChanPtr;
- if (chanPtr->downChanPtr != (Channel *) NULL) {
+ if (chanPtr->downChanPtr != NULL) {
/*
* Instead of manipulating the per-thread / per-interp list/hashtable
* of registered channels we wind down the state of the transformation,
@@ -1470,20 +1442,21 @@ Tcl_UnstackChannel(interp, chan)
CopyState *csPtr;
csPtr = statePtr->csPtr;
- statePtr->csPtr = (CopyState *) NULL;
+ statePtr->csPtr = NULL;
if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
statePtr->csPtr = csPtr;
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move error messages put by the driver into the chan/ip
* bypass area into the regular interpreter result. Fall back
* to the regular message if nothing was found in the
* bypasses.
*/
- if (!TclChanCaughtErrorBypass (interp, chan)) {
+ if (!TclChanCaughtErrorBypass(interp, chan)) {
Tcl_AppendResult(interp, "could not flush channel \"",
- Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
- (char *) NULL);
+ Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
+ NULL);
}
return TCL_ERROR;
}
@@ -1502,27 +1475,28 @@ Tcl_UnstackChannel(interp, chan)
*/
if (((statePtr->flags & TCL_READABLE) != 0) &&
- ((statePtr->inQueueHead != (ChannelBuffer *) NULL) ||
- (chanPtr->inQueueHead != (ChannelBuffer *) NULL))) {
+ ((statePtr->inQueueHead != NULL) ||
+ (chanPtr->inQueueHead != NULL))) {
- if ((statePtr->inQueueHead != (ChannelBuffer *) NULL) &&
- (chanPtr->inQueueHead != (ChannelBuffer *) NULL)) {
+ if ((statePtr->inQueueHead != NULL) &&
+ (chanPtr->inQueueHead != NULL)) {
statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
statePtr->inQueueHead = statePtr->inQueueTail;
- } else if (chanPtr->inQueueHead != (ChannelBuffer *) NULL) {
+ } else if (chanPtr->inQueueHead != NULL) {
statePtr->inQueueHead = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
}
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
DiscardInputQueued(statePtr, 0);
}
- /* TIP #218, Channel Thread Actions.
+ /*
+ * TIP #218, Channel Thread Actions.
*
* We call the thread actions for the new channel directly. We
* _cannot_ use CutChannel, because the (thread-)global list of all
@@ -1533,18 +1507,18 @@ Tcl_UnstackChannel(interp, chan)
* the state which are still active.
*/
- threadActionProc = Tcl_ChannelThreadActionProc (chanPtr->typePtr);
+ threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
if (threadActionProc != NULL) {
- (*threadActionProc) (chanPtr->instanceData,
- TCL_CHANNEL_THREAD_REMOVE);
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_REMOVE);
}
statePtr->topChanPtr = downChanPtr;
- downChanPtr->upChanPtr = (Channel *) NULL;
+ downChanPtr->upChanPtr = NULL;
/*
* Leave this link intact for closeproc
- * chanPtr->downChanPtr = (Channel *) NULL;
+ * chanPtr->downChanPtr = NULL;
*/
/*
@@ -1570,30 +1544,36 @@ Tcl_UnstackChannel(interp, chan)
if (result != 0) {
Tcl_SetErrno(result);
- /* TIP #219, Tcl Channel Reflection API.
+
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move error messages put by the driver into the chan/ip bypass
* area into the regular interpreter result.
*/
- TclChanCaughtErrorBypass (interp, chan);
+
+ TclChanCaughtErrorBypass(interp, chan);
return TCL_ERROR;
}
} else {
/*
- * This channel does not cover another one. Simply do a close, if
+ * This channel does not cover another one. Simply do a close, if
* necessary.
*/
if (statePtr->refCount <= 0) {
if (Tcl_Close(interp, chan) != TCL_OK) {
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* "TclChanCaughtErrorBypass" is not required here, it was
* done already by "Tcl_Close".
*/
+
return TCL_ERROR;
}
}
- /* TIP #218, Channel Thread Actions.
+ /*
+ * TIP #218, Channel Thread Actions.
* Not required in this branch, this is done by Tcl_Close. If
* Tcl_Close is not called then the ChannelState is still active in
* the thread and no action has to be taken either.
@@ -1622,8 +1602,8 @@ Tcl_UnstackChannel(interp, chan)
*/
Tcl_Channel
-Tcl_GetStackedChannel(chan)
- Tcl_Channel chan;
+Tcl_GetStackedChannel(
+ Tcl_Channel chan)
{
Channel *chanPtr = (Channel *) chan; /* The actual channel. */
@@ -1649,8 +1629,8 @@ Tcl_GetStackedChannel(chan)
*/
Tcl_Channel
-Tcl_GetTopChannel(chan)
- Tcl_Channel chan;
+Tcl_GetTopChannel(
+ Tcl_Channel chan)
{
Channel *chanPtr = (Channel *) chan; /* The actual channel. */
@@ -1674,8 +1654,8 @@ Tcl_GetTopChannel(chan)
*/
ClientData
-Tcl_GetChannelInstanceData(chan)
- Tcl_Channel chan; /* Channel for which to return client data. */
+Tcl_GetChannelInstanceData(
+ Tcl_Channel chan) /* Channel for which to return client data. */
{
Channel *chanPtr = (Channel *) chan; /* The actual channel. */
@@ -1687,7 +1667,7 @@ Tcl_GetChannelInstanceData(chan)
*
* Tcl_GetChannelThread --
*
- * Given a channel structure, returns the thread managing it. TIP #10
+ * Given a channel structure, returns the thread managing it. TIP #10
*
* Results:
* Returns the id of the thread managing the channel.
@@ -1699,8 +1679,8 @@ Tcl_GetChannelInstanceData(chan)
*/
Tcl_ThreadId
-Tcl_GetChannelThread(chan)
- Tcl_Channel chan; /* The channel to return managing thread
+Tcl_GetChannelThread(
+ Tcl_Channel chan) /* The channel to return the managing thread
* for. */
{
Channel *chanPtr = (Channel *) chan; /* The actual channel. */
@@ -1725,8 +1705,8 @@ Tcl_GetChannelThread(chan)
*/
Tcl_ChannelType *
-Tcl_GetChannelType(chan)
- Tcl_Channel chan; /* The channel to return type for. */
+Tcl_GetChannelType(
+ Tcl_Channel chan) /* The channel to return type for. */
{
Channel *chanPtr = (Channel *) chan;
/* The actual channel. */
@@ -1752,8 +1732,8 @@ Tcl_GetChannelType(chan)
*/
int
-Tcl_GetChannelMode(chan)
- Tcl_Channel chan; /* The channel for which the mode is being
+Tcl_GetChannelMode(
+ Tcl_Channel chan) /* The channel for which the mode is being
* computed. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
@@ -1780,8 +1760,8 @@ Tcl_GetChannelMode(chan)
*/
CONST char *
-Tcl_GetChannelName(chan)
- Tcl_Channel chan; /* The channel for which to return the name. */
+Tcl_GetChannelName(
+ Tcl_Channel chan) /* The channel for which to return the name. */
{
ChannelState *statePtr; /* State of actual channel. */
@@ -1807,10 +1787,10 @@ Tcl_GetChannelName(chan)
*/
int
-Tcl_GetChannelHandle(chan, direction, handlePtr)
- Tcl_Channel chan; /* The channel to get file from. */
- int direction; /* TCL_WRITABLE or TCL_READABLE. */
- ClientData *handlePtr; /* Where to store handle */
+Tcl_GetChannelHandle(
+ Tcl_Channel chan, /* The channel to get file from. */
+ int direction, /* TCL_WRITABLE or TCL_READABLE. */
+ ClientData *handlePtr) /* Where to store handle */
{
Channel *chanPtr; /* The actual channel. */
ClientData handle;
@@ -1850,8 +1830,8 @@ Tcl_GetChannelHandle(chan, direction, handlePtr)
*/
static ChannelBuffer *
-AllocChannelBuffer(length)
- int length; /* Desired length of channel buffer. */
+AllocChannelBuffer(
+ int length) /* Desired length of channel buffer. */
{
ChannelBuffer *bufPtr;
int n;
@@ -1861,7 +1841,7 @@ AllocChannelBuffer(length)
bufPtr->nextAdded = BUFFER_PADDING;
bufPtr->nextRemoved = BUFFER_PADDING;
bufPtr->bufLength = length + BUFFER_PADDING;
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
return bufPtr;
}
@@ -1885,10 +1865,10 @@ AllocChannelBuffer(length)
*/
static void
-RecycleBuffer(statePtr, bufPtr, mustDiscard)
- ChannelState *statePtr; /* ChannelState in which to recycle buffers. */
- ChannelBuffer *bufPtr; /* The buffer to recycle. */
- int mustDiscard; /* If nonzero, free the buffer to the OS,
+RecycleBuffer(
+ ChannelState *statePtr, /* ChannelState in which to recycle buffers. */
+ ChannelBuffer *bufPtr, /* The buffer to recycle. */
+ int mustDiscard) /* If nonzero, free the buffer to the OS,
* always. */
{
/*
@@ -1916,12 +1896,12 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
*/
if (statePtr->flags & TCL_READABLE) {
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+ if (statePtr->inQueueHead == NULL) {
statePtr->inQueueHead = bufPtr;
statePtr->inQueueTail = bufPtr;
goto keepBuffer;
}
- if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) {
+ if (statePtr->saveInBufPtr == NULL) {
statePtr->saveInBufPtr = bufPtr;
goto keepBuffer;
}
@@ -1932,7 +1912,7 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
*/
if (statePtr->flags & TCL_WRITABLE) {
- if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+ if (statePtr->curOutPtr == NULL) {
statePtr->curOutPtr = bufPtr;
goto keepBuffer;
}
@@ -1948,7 +1928,7 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
keepBuffer:
bufPtr->nextRemoved = BUFFER_PADDING;
bufPtr->nextAdded = BUFFER_PADDING;
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
}
/*
@@ -1968,18 +1948,18 @@ RecycleBuffer(statePtr, bufPtr, mustDiscard)
*/
static void
-DiscardOutputQueued(statePtr)
- ChannelState *statePtr; /* ChannelState for which to discard output. */
+DiscardOutputQueued(
+ ChannelState *statePtr) /* ChannelState for which to discard output. */
{
ChannelBuffer *bufPtr;
- while (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
+ while (statePtr->outQueueHead != NULL) {
bufPtr = statePtr->outQueueHead;
statePtr->outQueueHead = bufPtr->nextPtr;
RecycleBuffer(statePtr, bufPtr, 0);
}
- statePtr->outQueueHead = (ChannelBuffer *) NULL;
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
+ statePtr->outQueueHead = NULL;
+ statePtr->outQueueTail = NULL;
}
/*
@@ -2000,16 +1980,15 @@ DiscardOutputQueued(statePtr)
*/
static int
-CheckForDeadChannel(interp, statePtr)
- Tcl_Interp *interp; /* For error reporting (can be NULL) */
- ChannelState *statePtr; /* The channel state to check. */
+CheckForDeadChannel(
+ Tcl_Interp *interp, /* For error reporting (can be NULL) */
+ ChannelState *statePtr) /* The channel state to check. */
{
if (statePtr->flags & CHANNEL_DEAD) {
Tcl_SetErrno(EINVAL);
if (interp) {
Tcl_AppendResult(interp,
- "unable to access channel: invalid channel",
- (char *) NULL);
+ "unable to access channel: invalid channel", NULL);
}
return 1;
}
@@ -2031,32 +2010,30 @@ CheckForDeadChannel(interp, statePtr)
*
* Side effects:
* May produce output on a channel. May block indefinitely if the channel
- * is synchronous. May schedule an async flush on the channel. May
+ * is synchronous. May schedule an async flush on the channel. May
* recycle memory for buffers in the output queue.
*
*----------------------------------------------------------------------
*/
static int
-FlushChannel(interp, chanPtr, calledFromAsyncFlush)
- Tcl_Interp *interp; /* For error reporting during close. */
- Channel *chanPtr; /* The channel to flush on. */
- int calledFromAsyncFlush; /* If nonzero then we are being called
- * from an asynchronous flush
- * callback. */
+FlushChannel(
+ Tcl_Interp *interp, /* For error reporting during close. */
+ Channel *chanPtr, /* The channel to flush on. */
+ int calledFromAsyncFlush) /* If nonzero then we are being called from an
+ * asynchronous flush callback. */
{
ChannelState *statePtr = chanPtr->state;
- /* State of the channel stack. */
- ChannelBuffer *bufPtr; /* Iterates over buffered output
- * queue. */
- int toWrite; /* Amount of output data in current
- * buffer available to be written. */
- int written; /* Amount of output data actually
- * written in current round. */
- int errorCode = 0; /* Stores POSIX error codes from
- * channel driver operations. */
- int wroteSome = 0; /* Set to one if any data was written
- * to the driver. */
+ /* State of the channel stack. */
+ ChannelBuffer *bufPtr; /* Iterates over buffered output queue. */
+ int toWrite; /* Amount of output data in current buffer
+ * available to be written. */
+ int written; /* Amount of output data actually written in
+ * current round. */
+ int errorCode = 0; /* Stores POSIX error codes from channel
+ * driver operations. */
+ int wroteSome = 0; /* Set to one if any data was written to the
+ * driver. */
/*
* Prevent writing on a dead channel -- a channel that has been closed but
@@ -2081,19 +2058,19 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* queue.
*/
- if (((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ if (((statePtr->curOutPtr != NULL) &&
(statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
|| ((statePtr->flags & BUFFER_READY) &&
- (statePtr->outQueueHead == (ChannelBuffer *) NULL))) {
+ (statePtr->outQueueHead == NULL))) {
statePtr->flags &= (~(BUFFER_READY));
- statePtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
- if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+ statePtr->curOutPtr->nextPtr = NULL;
+ if (statePtr->outQueueHead == NULL) {
statePtr->outQueueHead = statePtr->curOutPtr;
} else {
statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
}
statePtr->outQueueTail = statePtr->curOutPtr;
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
+ statePtr->curOutPtr = NULL;
}
bufPtr = statePtr->outQueueHead;
@@ -2111,7 +2088,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
* If the output queue is still empty, break out of the while loop.
*/
- if (bufPtr == (ChannelBuffer *) NULL) {
+ if (bufPtr == NULL) {
break; /* Out of the "while (1)". */
}
@@ -2120,9 +2097,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
- written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
- bufPtr->buf + bufPtr->nextRemoved, toWrite,
- &errorCode);
+ written = (chanPtr->typePtr->outputProc)(chanPtr->instanceData,
+ bufPtr->buf + bufPtr->nextRemoved, toWrite, &errorCode);
/*
* If the write failed completely attempt to start the asynchronous
@@ -2131,7 +2107,6 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if (written < 0) {
-
/*
* If the last attempt to write was interrupted, simply retry.
*/
@@ -2149,7 +2124,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
/*
* This used to check for CHANNEL_NONBLOCKING, and panic if
- * the channel was blocking. However, it appears that setting
+ * the channel was blocking. However, it appears that setting
* stdin to -blocking 0 has some effect on the stdout when
* it's a tty channel (dup'ed underneath)
*/
@@ -2167,31 +2142,35 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if (calledFromAsyncFlush) {
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* When defering the error copy a message from the bypass into
* the unreported area. Or discard it if the new error is to be
* ignored in favor of an earlier defered error.
*/
- Tcl_Obj* msg = statePtr->chanMsg;
+ Tcl_Obj *msg = statePtr->chanMsg;
if (statePtr->unreportedError == 0) {
statePtr->unreportedError = errorCode;
statePtr->unreportedMsg = msg;
if (msg != NULL) {
- Tcl_IncrRefCount (msg);
+ Tcl_IncrRefCount(msg);
}
} else {
- /* An old unreported error is kept, and this error
- * thrown away.
+ /*
+ * An old unreported error is kept, and this error thrown
+ * away.
*/
+
statePtr->chanMsg = NULL;
if (msg != NULL) {
- Tcl_DecrRefCount (msg);
+ Tcl_DecrRefCount(msg);
}
}
} else {
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move error messages put by the driver into the chan bypass
* area into the regular interpreter result. Fall back to the
* regular message if nothing was found in the bypasses.
@@ -2199,20 +2178,20 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
Tcl_SetErrno(errorCode);
if (interp != NULL) {
- if (!TclChanCaughtErrorBypass (interp, (Tcl_Channel) chanPtr)) {
- /*
+ if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
+ /*
* Casting away CONST here is safe because the
- * TCL_VOLATILE flag guarantees CONST treatment
- * of the Posix error string.
+ * TCL_VOLATILE flag guarantees CONST treatment of the
+ * Posix error string.
*/
- Tcl_SetResult(interp,
- (char *) Tcl_PosixError(interp),
- TCL_VOLATILE);
+ Tcl_SetResult(interp,
+ (char *) Tcl_PosixError(interp), TCL_VOLATILE);
}
}
- /* An unreportable bypassed message is kept, for the
- * caller of Tcl_Seek, Tcl_Write, etc.
+ /*
+ * An unreportable bypassed message is kept, for the caller of
+ * Tcl_Seek, Tcl_Write, etc.
*/
}
@@ -2235,8 +2214,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
statePtr->outQueueHead = bufPtr->nextPtr;
- if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
- statePtr->outQueueTail = (ChannelBuffer *) NULL;
+ if (statePtr->outQueueHead == NULL) {
+ statePtr->outQueueTail = NULL;
}
RecycleBuffer(statePtr, bufPtr, 0);
}
@@ -2245,14 +2224,14 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
/*
* If we wrote some data while flushing in the background, we are done.
* We can't finish the background flush until we run out of data and the
- * channel becomes writable again. This ensures that all of the pending
+ * channel becomes writable again. This ensures that all of the pending
* data has been flushed at the system level.
*/
if (statePtr->flags & BG_FLUSH_SCHEDULED) {
if (wroteSome) {
return errorCode;
- } else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
+ } else if (statePtr->outQueueHead == NULL) {
statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
statePtr->interestMask);
@@ -2266,8 +2245,8 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
- (statePtr->outQueueHead == (ChannelBuffer *) NULL) &&
- ((statePtr->curOutPtr == (ChannelBuffer *) NULL) ||
+ (statePtr->outQueueHead == NULL) &&
+ ((statePtr->curOutPtr == NULL) ||
(statePtr->curOutPtr->nextAdded ==
statePtr->curOutPtr->nextRemoved))) {
return CloseChannel(interp, chanPtr, errorCode);
@@ -2284,7 +2263,7 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*
* If the channel was stacked, then the it will copy the necessary
* elements of the NEXT channel into the TOP channel, in essence
- * unstacking the channel. The NEXT channel will then be freed.
+ * unstacking the channel. The NEXT channel will then be freed.
*
* If the channel was not stacked, then we will free all the bits for the
* TOP channel, including the data structure itself.
@@ -2300,14 +2279,13 @@ FlushChannel(interp, chanPtr, calledFromAsyncFlush)
*/
static int
-CloseChannel(interp, chanPtr, errorCode)
- Tcl_Interp *interp; /* For error reporting. */
- Channel *chanPtr; /* The channel to close. */
- int errorCode; /* Status of operation so far. */
-{
- int result = 0; /* Of calling driver close
- * operation. */
- ChannelState *statePtr; /* state of the channel stack. */
+CloseChannel(
+ Tcl_Interp *interp, /* For error reporting. */
+ Channel *chanPtr, /* The channel to close. */
+ int errorCode) /* Status of operation so far. */
+{
+ int result = 0; /* Of calling driver close operation. */
+ ChannelState *statePtr; /* State of the channel stack. */
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if (chanPtr == NULL) {
@@ -2325,16 +2303,16 @@ CloseChannel(interp, chanPtr, errorCode)
* Discard a leftover buffer in the current output buffer field.
*/
- if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
+ if (statePtr->curOutPtr != NULL) {
ckfree((char *) statePtr->curOutPtr);
- statePtr->curOutPtr = (ChannelBuffer *) NULL;
+ statePtr->curOutPtr = NULL;
}
/*
* The caller guarantees that there are no more buffers queued for output.
*/
- if (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
+ if (statePtr->outQueueHead != NULL) {
Tcl_Panic("TclFlush, closed channel: queued output left");
}
@@ -2347,19 +2325,20 @@ CloseChannel(interp, chanPtr, errorCode)
int dummy;
char c = (char) statePtr->outEofChar;
- (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
+ (chanPtr->typePtr->outputProc)(chanPtr->instanceData, &c, 1, &dummy);
}
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move a leftover error message in the channel bypass into the
* interpreter bypass. Just clear it if there is no interpreter.
*/
if (statePtr->chanMsg != NULL) {
if (interp != NULL) {
- Tcl_SetChannelErrorInterp (interp,statePtr->chanMsg);
+ Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
}
- Tcl_DecrRefCount (statePtr->chanMsg);
+ Tcl_DecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
@@ -2387,7 +2366,7 @@ CloseChannel(interp, chanPtr, errorCode)
*/
if (chanPtr == statePtr->bottomChanPtr) {
- if (statePtr->channelName != (char *) NULL) {
+ if (statePtr->channelName != NULL) {
ckfree((char *) statePtr->channelName);
statePtr->channelName = NULL;
}
@@ -2395,7 +2374,7 @@ CloseChannel(interp, chanPtr, errorCode)
Tcl_FreeEncoding(statePtr->encoding);
if (statePtr->outputStage != NULL) {
ckfree((char *) statePtr->outputStage);
- statePtr->outputStage = (char *) NULL;
+ statePtr->outputStage = NULL;
}
}
@@ -2413,10 +2392,10 @@ CloseChannel(interp, chanPtr, errorCode)
*/
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount (statePtr->chanMsg);
+ Tcl_DecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
- Tcl_SetChannelErrorInterp (interp,statePtr->unreportedMsg);
+ Tcl_SetChannelErrorInterp(interp,statePtr->unreportedMsg);
}
if (errorCode == 0) {
errorCode = result;
@@ -2435,15 +2414,15 @@ CloseChannel(interp, chanPtr, errorCode)
* Mark the channel as deleted by clearing the type structure.
*/
- if (chanPtr->downChanPtr != (Channel *) NULL) {
+ if (chanPtr->downChanPtr != NULL) {
Channel *downChanPtr = chanPtr->downChanPtr;
- statePtr->nextCSPtr = tsdPtr->firstCSPtr;
- tsdPtr->firstCSPtr = statePtr;
+ statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+ tsdPtr->firstCSPtr = statePtr;
- statePtr->topChanPtr = downChanPtr;
- downChanPtr->upChanPtr = (Channel *) NULL;
- chanPtr->typePtr = NULL;
+ statePtr->topChanPtr = downChanPtr;
+ downChanPtr->upChanPtr = NULL;
+ chanPtr->typePtr = NULL;
Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
@@ -2451,7 +2430,7 @@ CloseChannel(interp, chanPtr, errorCode)
/*
* There is only the TOP Channel, so we free the remaining pointers we
- * have and then ourselves. Since this is the last of the channels in the
+ * have and then ourselves. Since this is the last of the channels in the
* stack, make sure to free the ChannelState structure associated with it.
* We use Tcl_EventuallyFree to allow for any last references.
*/
@@ -2471,7 +2450,7 @@ CloseChannel(interp, chanPtr, errorCode)
* CutChannel --
*
* Removes a channel from the (thread-)global list of all channels (in
- * that thread). This is actually the statePtr for the stack of channel.
+ * that thread). This is actually the statePtr for the stack of channel.
*
* Results:
* Nothing.
@@ -2490,17 +2469,16 @@ CloseChannel(interp, chanPtr, errorCode)
*/
static void
-CutChannel(chan)
- Tcl_Channel chan; /* The channel being removed. Must
- * not be referenced in any
- * interpreter. */
+CutChannel(
+ Tcl_Channel chan) /* The channel being removed. Must not be
+ * referenced in any interpreter. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *prevCSPtr; /* Preceding channel state in list of
- * all states - used to splice a
- * channel out of the list on close. */
+ ChannelState *prevCSPtr; /* Preceding channel state in list of all
+ * states - used to splice a channel out of
+ * the list on close. */
ChannelState *statePtr = ((Channel *) chan)->state;
- /* state of the channel stack. */
+ /* state of the channel stack. */
Tcl_DriverThreadActionProc *threadActionProc;
/*
@@ -2516,35 +2494,37 @@ CutChannel(chan)
prevCSPtr = prevCSPtr->nextCSPtr) {
/* Empty loop body. */
}
- if (prevCSPtr == (ChannelState *) NULL) {
+ if (prevCSPtr == NULL) {
Tcl_Panic("FlushChannel: damaged channel list");
}
prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
}
- statePtr->nextCSPtr = (ChannelState *) NULL;
+ statePtr->nextCSPtr = NULL;
+
+ /*
+ * TIP #218, Channel Thread Actions
+ */
- /* TIP #218, Channel Thread Actions */
threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan));
if (threadActionProc != NULL) {
- (*threadActionProc) (Tcl_GetChannelInstanceData(chan),
+ (*threadActionProc)(Tcl_GetChannelInstanceData(chan),
TCL_CHANNEL_THREAD_REMOVE);
}
}
void
-Tcl_CutChannel(chan)
- Tcl_Channel chan; /* The channel being added. Must not
- * be referenced in any
- * interpreter. */
+Tcl_CutChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
{
Channel* chanPtr = ((Channel*) chan)->state->bottomChanPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *prevCSPtr; /* Preceding channel state in list of
- * all states - used to splice a
- * channel out of the list on close. */
+ ChannelState *prevCSPtr; /* Preceding channel state in list of all
+ * states - used to splice a channel out of
+ * the list on close. */
ChannelState *statePtr = chanPtr->state;
- /* state of the channel stack. */
+ /* state of the channel stack. */
Tcl_DriverThreadActionProc *threadActionProc;
/*
@@ -2560,23 +2540,24 @@ Tcl_CutChannel(chan)
prevCSPtr = prevCSPtr->nextCSPtr) {
/* Empty loop body. */
}
- if (prevCSPtr == (ChannelState *) NULL) {
+ if (prevCSPtr == NULL) {
Tcl_Panic("FlushChannel: damaged channel list");
}
prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
}
- statePtr->nextCSPtr = (ChannelState *) NULL;
+ statePtr->nextCSPtr = NULL;
- /* TIP #218, Channel Thread Actions
+ /*
+ * TIP #218, Channel Thread Actions
* For all transformations and the base channel.
*/
while (chanPtr) {
threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
if (threadActionProc != NULL) {
- (*threadActionProc) (chanPtr->instanceData,
- TCL_CHANNEL_THREAD_REMOVE);
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_REMOVE);
}
chanPtr= chanPtr->upChanPtr;
}
@@ -2609,16 +2590,15 @@ Tcl_CutChannel(chan)
*/
static void
-SpliceChannel(chan)
- Tcl_Channel chan; /* The channel being added. Must not
- * be referenced in any
- * interpreter. */
+SpliceChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
{
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *statePtr = ((Channel *) chan)->state;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *statePtr = ((Channel *) chan)->state;
Tcl_DriverThreadActionProc *threadActionProc;
- if (statePtr->nextCSPtr != (ChannelState *) NULL) {
+ if (statePtr->nextCSPtr != NULL) {
Tcl_Panic("SpliceChannel: trying to add channel used in different list");
}
@@ -2633,7 +2613,10 @@ SpliceChannel(chan)
statePtr->managingThread = Tcl_GetCurrentThread();
- /* TIP #218, Channel Thread Actions */
+ /*
+ * TIP #218, Channel Thread Actions
+ */
+
threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan));
if (threadActionProc != NULL) {
(*threadActionProc) (Tcl_GetChannelInstanceData(chan),
@@ -2642,17 +2625,16 @@ SpliceChannel(chan)
}
void
-Tcl_SpliceChannel(chan)
- Tcl_Channel chan; /* The channel being added. Must not
- * be referenced in any
- * interpreter. */
-{
- Channel *chanPtr = ((Channel*) chan)->state->bottomChanPtr;
- ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
- ChannelState *statePtr = chanPtr->state;
+Tcl_SpliceChannel(
+ Tcl_Channel chan) /* The channel being added. Must not be
+ * referenced in any interpreter. */
+{
+ Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+ ChannelState *statePtr = chanPtr->state;
Tcl_DriverThreadActionProc *threadActionProc;
- if (statePtr->nextCSPtr != (ChannelState *) NULL) {
+ if (statePtr->nextCSPtr != NULL) {
Tcl_Panic("SpliceChannel: trying to add channel used in different list");
}
@@ -2667,15 +2649,16 @@ Tcl_SpliceChannel(chan)
statePtr->managingThread = Tcl_GetCurrentThread();
- /* TIP #218, Channel Thread Actions
+ /*
+ * TIP #218, Channel Thread Actions
* For all transformations and the base channel.
*/
while (chanPtr) {
threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
if (threadActionProc != NULL) {
- (*threadActionProc) (chanPtr->instanceData,
- TCL_CHANNEL_THREAD_INSERT);
+ (*threadActionProc)(chanPtr->instanceData,
+ TCL_CHANNEL_THREAD_INSERT);
}
chanPtr= chanPtr->upChanPtr;
}
@@ -2705,20 +2688,19 @@ Tcl_SpliceChannel(chan)
/* ARGSUSED */
int
-Tcl_Close(interp, chan)
- Tcl_Interp *interp; /* Interpreter for errors. */
- Tcl_Channel chan; /* The channel being closed. Must not
- * be referenced in any
- * interpreter. */
-{
- CloseCallback *cbPtr; /* Iterate over close callbacks for
- * this channel. */
- Channel *chanPtr; /* The real IO channel. */
- ChannelState *statePtr; /* State of real IO channel. */
- int result; /* Of calling FlushChannel. */
+Tcl_Close(
+ Tcl_Interp *interp, /* Interpreter for errors. */
+ Tcl_Channel chan) /* The channel being closed. Must not be
+ * referenced in any interpreter. */
+{
+ CloseCallback *cbPtr; /* Iterate over close callbacks for this
+ * channel. */
+ Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of real IO channel. */
+ int result; /* Of calling FlushChannel. */
int flushcode;
- if (chan == (Tcl_Channel) NULL) {
+ if (chan == NULL) {
return TCL_OK;
}
@@ -2746,7 +2728,7 @@ Tcl_Close(interp, chan)
if (statePtr->flags & CHANNEL_INCLOSE) {
Tcl_AppendResult(interp, "Illegal recursive call to close ",
- "through close-handler of channel", (char *) NULL);
+ "through close-handler of channel", NULL);
return TCL_ERROR;
}
statePtr->flags |= CHANNEL_INCLOSE;
@@ -2761,16 +2743,17 @@ Tcl_Close(interp, chan)
statePtr->outputEncodingFlags |= TCL_ENCODING_END;
WriteChars(chanPtr, "", 0);
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move an error message found in the channel bypass into the
* interpreter bypass. Just clear it if there is no interpreter.
*/
if (statePtr->chanMsg != NULL) {
if (interp != NULL) {
- Tcl_SetChannelErrorInterp (interp,statePtr->chanMsg);
+ Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
}
- Tcl_DecrRefCount (statePtr->chanMsg);
+ Tcl_DecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
}
@@ -2781,10 +2764,10 @@ Tcl_Close(interp, chan)
* Invoke the registered close callbacks and delete their records.
*/
- while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
+ while (statePtr->closeCbPtr != NULL) {
cbPtr = statePtr->closeCbPtr;
statePtr->closeCbPtr = cbPtr->nextPtr;
- (cbPtr->proc) (cbPtr->clientData);
+ (cbPtr->proc)(cbPtr->clientData);
ckfree((char *) cbPtr);
}
@@ -2794,8 +2777,8 @@ Tcl_Close(interp, chan)
* Ensure that the last output buffer will be flushed.
*/
- if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
+ if ((statePtr->curOutPtr != NULL) &&
+ (statePtr->curOutPtr->nextAdded>statePtr->curOutPtr->nextRemoved)){
statePtr->flags |= BUFFER_READY;
}
@@ -2821,7 +2804,8 @@ Tcl_Close(interp, chan)
flushcode = FlushChannel(interp, chanPtr, 0);
- /* TIP #219.
+ /*
+ * TIP #219.
* Capture error messages put by the driver into the bypass area and put
* them into the regular interpreter result.
*
@@ -2832,7 +2816,8 @@ Tcl_Close(interp, chan)
* message is the interpreter itself, and "CloseChannel" made sure to lift
* any channel message it generated into it.
*/
- if (TclChanCaughtErrorBypass (interp, NULL)) {
+
+ if (TclChanCaughtErrorBypass(interp, NULL)) {
result = EINVAL;
}
@@ -2861,8 +2846,8 @@ Tcl_Close(interp, chan)
*/
void
-Tcl_ClearChannelHandlers(channel)
- Tcl_Channel channel;
+Tcl_ClearChannelHandlers(
+ Tcl_Channel channel)
{
ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */
EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */
@@ -2890,8 +2875,7 @@ Tcl_ClearChannelHandlers(channel)
* about to be invoked.
*/
- for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
+ for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
nhPtr = nhPtr->nestedHandlerPtr) {
if (nhPtr->nextHandlerPtr &&
(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
@@ -2903,13 +2887,11 @@ Tcl_ClearChannelHandlers(channel)
* Remove all the channel handler records attached to the channel itself.
*/
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chNext) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) {
chNext = chPtr->nextPtr;
ckfree((char *) chPtr);
}
- statePtr->chPtr = (ChannelHandler *) NULL;
+ statePtr->chPtr = NULL;
/*
* Cancel any pending copy operation.
@@ -2930,14 +2912,12 @@ Tcl_ClearChannelHandlers(channel)
* Remove any EventScript records for this channel.
*/
- for (ePtr = statePtr->scriptRecordPtr;
- ePtr != (EventScriptRecord *) NULL;
- ePtr = eNextPtr) {
+ for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) {
eNextPtr = ePtr->nextPtr;
TclDecrRefCount(ePtr->scriptPtr);
ckfree((char *) ePtr);
}
- statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
+ statePtr->scriptRecordPtr = NULL;
}
/*
@@ -2965,11 +2945,11 @@ Tcl_ClearChannelHandlers(channel)
*/
int
-Tcl_Write(chan, src, srcLen)
- Tcl_Channel chan; /* The channel to buffer output for. */
- CONST char *src; /* Data to queue in output buffer. */
- int srcLen; /* Length of data in bytes, or < 0 for
- * strlen(). */
+Tcl_Write(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ CONST char *src, /* Data to queue in output buffer. */
+ int srcLen) /* Length of data in bytes, or < 0 for
+ * strlen(). */
{
/*
* Always use the topmost channel of the stack
@@ -3016,11 +2996,11 @@ Tcl_Write(chan, src, srcLen)
*/
int
-Tcl_WriteRaw(chan, src, srcLen)
- Tcl_Channel chan; /* The channel to buffer output for. */
- CONST char *src; /* Data to queue in output buffer. */
- int srcLen; /* Length of data in bytes, or < 0 for
- * strlen(). */
+Tcl_WriteRaw(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ CONST char *src, /* Data to queue in output buffer. */
+ int srcLen) /* Length of data in bytes, or < 0 for
+ * strlen(). */
{
Channel *chanPtr = ((Channel *) chan);
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -3073,11 +3053,11 @@ Tcl_WriteRaw(chan, src, srcLen)
*/
int
-Tcl_WriteChars(chan, src, len)
- Tcl_Channel chan; /* The channel to buffer output for. */
- CONST char *src; /* UTF-8 characters to queue in output
+Tcl_WriteChars(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ CONST char *src, /* UTF-8 characters to queue in output
* buffer. */
- int len; /* Length of string in bytes, or < 0 for
+ int len) /* Length of string in bytes, or < 0 for
* strlen(). */
{
ChannelState *statePtr; /* state info for channel */
@@ -3115,11 +3095,11 @@ Tcl_WriteChars(chan, src, len)
*/
static int
-DoWriteChars(chanPtr, src, len)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* UTF-8 characters to queue in output
+DoWriteChars(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ CONST char *src, /* UTF-8 characters to queue in output
* buffer. */
- int len; /* Length of string in bytes, or < 0 for
+ int len) /* Length of string in bytes, or < 0 for
* strlen(). */
{
/*
@@ -3157,11 +3137,11 @@ DoWriteChars(chanPtr, src, len)
*
* Tcl_WriteObj --
*
- * Takes the Tcl object and queues its contents for output. If the
+ * Takes the Tcl object and queues its contents for output. If the
* encoding of the channel is NULL, takes the byte-array representation
- * of the object and queues those bytes for output. Otherwise, takes the
+ * of the object and queues those bytes for output. Otherwise, takes the
* characters in the UTF-8 (string) representation of the object and
- * converts them for output using the channel's current encoding. May
+ * converts them for output using the channel's current encoding. May
* flush internal buffers to output if one becomes full or is ready for
* some other reason, e.g. if it contains a newline and the channel is in
* line buffering mode.
@@ -3178,9 +3158,9 @@ DoWriteChars(chanPtr, src, len)
*/
int
-Tcl_WriteObj(chan, objPtr)
- Tcl_Channel chan; /* The channel to buffer output for. */
- Tcl_Obj *objPtr; /* The object to write. */
+Tcl_WriteObj(
+ Tcl_Channel chan, /* The channel to buffer output for. */
+ Tcl_Obj *objPtr) /* The object to write. */
{
/*
* Always use the topmost channel of the stack
@@ -3228,10 +3208,10 @@ Tcl_WriteObj(chan, objPtr)
*/
static int
-WriteBytes(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* Bytes to write. */
- int srcLen; /* Number of bytes to write. */
+WriteBytes(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ CONST char *src, /* Bytes to write. */
+ int srcLen) /* Number of bytes to write. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
@@ -3265,7 +3245,7 @@ WriteBytes(chanPtr, src, srcLen)
if (savedLF) {
/*
* A '\n' was left over from last call to TranslateOutputEOL() and
- * we need to store it in this buffer. If the channel is
+ * we need to store it in this buffer. If the channel is
* line-based, we will need to flush it.
*/
@@ -3317,10 +3297,10 @@ WriteBytes(chanPtr, src, srcLen)
*/
static int
-WriteChars(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* UTF-8 string to write. */
- int srcLen; /* Length of UTF-8 string in bytes. */
+WriteChars(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ CONST char *src, /* UTF-8 string to write. */
+ int srcLen) /* Length of UTF-8 string in bytes. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
@@ -3443,7 +3423,7 @@ WriteChars(chanPtr, src, srcLen)
if ((result != 0) && ((stageRead + dstWrote) == 0)) {
/*
* We have an incomplete UTF-8 character at the end of the
- * staging buffer. It will get moved to the beginning of the
+ * staging buffer. It will get moved to the beginning of the
* staging buffer followed by more bytes from src.
*/
@@ -3459,7 +3439,7 @@ WriteChars(chanPtr, src, srcLen)
* When translating from UTF-8 to external encoding, we
* allowed the translation to produce a character that crossed
* the end of the output buffer, so that we would get a
- * completely full buffer before flushing it. The extra bytes
+ * completely full buffer before flushing it. The extra bytes
* will be moved to the beginning of the next buffer.
*/
@@ -3507,7 +3487,7 @@ WriteChars(chanPtr, src, srcLen)
*
* TranslateOutputEOL --
*
- * Helper function for WriteBytes() and WriteChars(). Converts the '\n'
+ * Helper function for WriteBytes() and WriteChars(). Converts the '\n'
* characters in the source buffer into the appropriate EOL form
* specified by the output translation mode.
*
@@ -3516,7 +3496,7 @@ WriteChars(chanPtr, src, srcLen)
*
* When converting to CRLF mode and there is only 1 byte left in the
* output buffer, this routine stores the '\r' in the last byte and then
- * stores the '\n' in the byte just past the end of the buffer. The
+ * stores the '\n' in the byte just past the end of the buffer. The
* caller is responsible for passing in a buffer that is large enough to
* hold the extra byte.
*
@@ -3526,7 +3506,7 @@ WriteChars(chanPtr, src, srcLen)
* line-based channel even though the channel buffer is not full.
*
* *dstLenPtr is filled with how many bytes of the output buffer were
- * used. As mentioned above, this can be one more that the output
+ * used. As mentioned above, this can be one more that the output
* buffer's specified length if a CRLF was stored.
*
* *srcLenPtr is filled with how many bytes of the source buffer were
@@ -3542,17 +3522,17 @@ WriteChars(chanPtr, src, srcLen)
*/
static int
-TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
- ChannelState *statePtr; /* Channel being read, for translation and
+TranslateOutputEOL(
+ ChannelState *statePtr, /* Channel being read, for translation and
* buffering modes. */
- char *dst; /* Output buffer filled with UTF-8 chars by
+ char *dst, /* Output buffer filled with UTF-8 chars by
* applying appropriate EOL translation to
* source characters. */
- CONST char *src; /* Source UTF-8 characters. */
- int *dstLenPtr; /* On entry, the maximum length of output
- * buffer in bytes. On exit, the number of
+ CONST char *src, /* Source UTF-8 characters. */
+ int *dstLenPtr, /* On entry, the maximum length of output
+ * buffer in bytes. On exit, the number of
* bytes actually used in output buffer. */
- int *srcLenPtr; /* On entry, the length of source buffer. On
+ int *srcLenPtr) /* On entry, the length of source buffer. On
* exit, the number of bytes read from the
* source buffer. */
{
@@ -3630,7 +3610,7 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
*
* CheckFlush --
*
- * Helper function for WriteBytes() and WriteChars(). If the channel
+ * Helper function for WriteBytes() and WriteChars(). If the channel
* buffer is ready to be flushed, flush it.
*
* Results:
@@ -3644,10 +3624,10 @@ TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
*/
static int
-CheckFlush(chanPtr, bufPtr, newlineFlag)
- Channel *chanPtr; /* Channel being read, for buffering mode. */
- ChannelBuffer *bufPtr; /* Channel buffer to possibly flush. */
- int newlineFlag; /* Non-zero if a the channel buffer contains a
+CheckFlush(
+ Channel *chanPtr, /* Channel being read, for buffering mode. */
+ ChannelBuffer *bufPtr, /* Channel buffer to possibly flush. */
+ int newlineFlag) /* Non-zero if a the channel buffer contains a
* newline. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -3690,17 +3670,17 @@ CheckFlush(chanPtr, bufPtr, newlineFlag)
* error or condition that occurred.
*
* Side effects:
- * May flush output on the channel. May cause input to be consumed from
+ * May flush output on the channel. May cause input to be consumed from
* the channel.
*
*---------------------------------------------------------------------------
*/
int
-Tcl_Gets(chan, lineRead)
- Tcl_Channel chan; /* Channel from which to read. */
- Tcl_DString *lineRead; /* The line read will be appended to this
- * DString as UTF-8 characters. The caller
+Tcl_Gets(
+ Tcl_Channel chan, /* Channel from which to read. */
+ Tcl_DString *lineRead) /* The line read will be appended to this
+ * DString as UTF-8 characters. The caller
* must have initialized it and is responsible
* for managing the storage. */
{
@@ -3724,27 +3704,27 @@ Tcl_Gets(chan, lineRead)
* Tcl_GetsObj --
*
* Accumulate input from the input channel until end-of-line or
- * end-of-file has been seen. Bytes read from the input channel are
+ * end-of-file has been seen. Bytes read from the input channel are
* converted to UTF-8 using the encoding specified by the channel.
*
* Results:
* Number of characters accumulated in the object or -1 if error,
- * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX
- * error code for the error or condition that occurred.
+ * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error
+ * code for the error or condition that occurred.
*
* Side effects:
* Consumes input from the channel.
*
- * On reading EOF, leave channel pointing at EOF char. On reading EOL,
+ * On reading EOF, leave channel pointing at EOF char. On reading EOL,
* leave channel pointing after EOL, but don't return EOL in dst buffer.
*
*---------------------------------------------------------------------------
*/
int
-Tcl_GetsObj(chan, objPtr)
- Tcl_Channel chan; /* Channel from which to read. */
- Tcl_Obj *objPtr; /* The line read will be appended to this
+Tcl_GetsObj(
+ Tcl_Channel chan, /* Channel from which to read. */
+ Tcl_Obj *objPtr) /* The line read will be appended to this
* object as UTF-8 characters. */
{
GetsState gs;
@@ -3951,7 +3931,7 @@ Tcl_GetsObj(chan, objPtr)
}
if (eof != NULL) {
/*
- * EOF character was seen. On EOF, leave current file position
+ * EOF character was seen. On EOF, leave current file position
* pointing at the EOF character, but don't store the EOF
* character in the output string.
*/
@@ -3981,10 +3961,10 @@ Tcl_GetsObj(chan, objPtr)
/*
* Found EOL or EOF, but the output buffer may now contain too many UTF-8
- * characters. We need to know how many raw bytes correspond to the
- * number of UTF-8 characters we want, plus how many raw bytes correspond
- * to the character(s) making up EOL (if any), so we can remove the
- * correct number of bytes from the channel buffer.
+ * characters. We need to know how many raw bytes correspond to the number
+ * of UTF-8 characters we want, plus how many raw bytes correspond to the
+ * character(s) making up EOL (if any), so we can remove the correct
+ * number of bytes from the channel buffer.
*/
gotEOL:
@@ -4008,7 +3988,7 @@ Tcl_GetsObj(chan, objPtr)
goto done;
/*
- * Couldn't get a complete line. This only happens if we get a error
+ * Couldn't get a complete line. This only happens if we get a error
* reading from the channel or we are non-blocking and there wasn't an EOL
* or EOF in the data available.
*/
@@ -4028,13 +4008,13 @@ Tcl_GetsObj(chan, objPtr)
/*
* We didn't get a complete line so we need to indicate to UpdateInterest
- * that the gets blocked. It will wait for more data instead of firing a
- * timer, avoiding a busy wait. This is where we are assuming that the
- * next operation is a gets. No more file events will be delivered on
- * this channel until new data arrives or some operation is performed on
- * the channel (e.g. gets, read, fconfigure) that changes the blocking
- * state. Note that this means a file event will not be delivered even
- * though a read would be able to consume the buffered data.
+ * that the gets blocked. It will wait for more data instead of firing a
+ * timer, avoiding a busy wait. This is where we are assuming that the
+ * next operation is a gets. No more file events will be delivered on this
+ * channel until new data arrives or some operation is performed on the
+ * channel (e.g. gets, read, fconfigure) that changes the blocking state.
+ * Note that this means a file event will not be delivered even though a
+ * read would be able to consume the buffered data.
*/
statePtr->flags |= CHANNEL_NEED_MORE_DATA;
@@ -4049,18 +4029,18 @@ Tcl_GetsObj(chan, objPtr)
UpdateInterest(chanPtr);
return copiedTotal;
}
-
+
/*
*---------------------------------------------------------------------------
*
* FilterInputBytes --
*
- * Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw
+ * Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw
* bytes read from the channel.
*
- * Consumes available bytes from channel buffers. When channel buffers
+ * Consumes available bytes from channel buffers. When channel buffers
* are exhausted, reads more bytes from channel device into a new channel
- * buffer. It is the caller's responsibility to free the channel buffers
+ * buffer. It is the caller's responsibility to free the channel buffers
* that have been exhausted.
*
* Results:
@@ -4075,9 +4055,9 @@ Tcl_GetsObj(chan, objPtr)
*/
static int
-FilterInputBytes(chanPtr, gsPtr)
- Channel *chanPtr; /* Channel to read. */
- GetsState *gsPtr; /* Current state of gets operation. */
+FilterInputBytes(
+ Channel *chanPtr, /* Channel to read. */
+ GetsState *gsPtr) /* Current state of gets operation. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
@@ -4086,7 +4066,7 @@ FilterInputBytes(chanPtr, gsPtr)
int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length;
Tcl_Obj *objPtr;
#define ENCODING_LINESIZE 20 /* Lower bound on how many bytes to convert at
- * a time. Since we don't know a priori how
+ * a time. Since we don't know a priori how
* many bytes of storage this many source
* bytes will use, we actually need at least
* ENCODING_LINESIZE * TCL_MAX_UTF bytes of
@@ -4111,7 +4091,7 @@ FilterInputBytes(chanPtr, gsPtr)
if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) {
/*
* All channel buffers were exhausted and the caller still hasn't seen
- * EOL. Need to read more bytes from the channel device. Side effect
+ * EOL. Need to read more bytes from the channel device. Side effect
* is to allocate another channel buffer.
*/
@@ -4134,8 +4114,8 @@ FilterInputBytes(chanPtr, gsPtr)
}
/*
- * Convert some of the bytes from the channel buffer to UTF-8. Space in
- * objPtr's string rep is used to hold the UTF-8 characters. Grow the
+ * Convert some of the bytes from the channel buffer to UTF-8. Space in
+ * objPtr's string rep is used to hold the UTF-8 characters. Grow the
* string rep if we need more space.
*/
@@ -4171,7 +4151,7 @@ FilterInputBytes(chanPtr, gsPtr)
/*
* Make sure that if we go through 'gets', that we reset the
- * TCL_ENCODING_START flag still. [Bug #523988]
+ * TCL_ENCODING_START flag still. [Bug #523988]
*/
statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
@@ -4179,7 +4159,7 @@ FilterInputBytes(chanPtr, gsPtr)
if (result == TCL_CONVERT_MULTIBYTE) {
/*
* The last few bytes in this channel buffer were the start of a
- * multibyte sequence. If this buffer was full, then move them to the
+ * multibyte sequence. If this buffer was full, then move them to the
* next buffer so the bytes will be contiguous.
*/
@@ -4190,20 +4170,20 @@ FilterInputBytes(chanPtr, gsPtr)
if (bufPtr->nextAdded < bufPtr->bufLength) {
if (gsPtr->rawRead > 0) {
/*
- * Some raw bytes were converted to UTF-8. Fall through,
+ * Some raw bytes were converted to UTF-8. Fall through,
* returning those UTF-8 characters because a EOL might be
* present in them.
*/
} else if (statePtr->flags & CHANNEL_EOF) {
/*
* There was a partial character followed by EOF on the
- * device. Fall through, returning that nothing was found.
+ * device. Fall through, returning that nothing was found.
*/
bufPtr->nextRemoved = bufPtr->nextAdded;
} else {
/*
- * There are no more cached raw bytes left. See if we can get
+ * There are no more cached raw bytes left. See if we can get
* some more.
*/
@@ -4232,7 +4212,7 @@ FilterInputBytes(chanPtr, gsPtr)
*
* PeekAhead --
*
- * Helper function used by Tcl_GetsObj(). Called when we've seen a \r at
+ * Helper function used by Tcl_GetsObj(). Called when we've seen a \r at
* the end of the UTF-8 string and want to look ahead one character to
* see if it is a \n.
*
@@ -4250,11 +4230,11 @@ FilterInputBytes(chanPtr, gsPtr)
*/
static void
-PeekAhead(chanPtr, dstEndPtr, gsPtr)
- Channel *chanPtr; /* The channel to read. */
- char **dstEndPtr; /* Filled with pointer to end of new range of
+PeekAhead(
+ Channel *chanPtr, /* The channel to read. */
+ char **dstEndPtr, /* Filled with pointer to end of new range of
* UTF-8 characters. */
- GetsState *gsPtr; /* Current state of gets operation. */
+ GetsState *gsPtr) /* Current state of gets operation. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr;
@@ -4266,7 +4246,7 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
/*
* If there's any more raw input that's still buffered, we'll peek into
* that. Otherwise, only get more data from the channel driver if it looks
- * like there might actually be more data. The assumption is that if the
+ * like there might actually be more data. The assumption is that if the
* channel buffer is filled right up to the end, then there might be more
* data to read.
*/
@@ -4329,9 +4309,9 @@ PeekAhead(chanPtr, dstEndPtr, gsPtr)
*/
static void
-CommonGetsCleanup(chanPtr, encoding)
- Channel *chanPtr;
- Tcl_Encoding encoding;
+CommonGetsCleanup(
+ Channel *chanPtr,
+ Tcl_Encoding encoding)
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
ChannelBuffer *bufPtr, *nextPtr;
@@ -4351,10 +4331,10 @@ CommonGetsCleanup(chanPtr, encoding)
/*
* If any multi-byte characters were split across channel buffer
* boundaries, the split-up bytes were moved to the next channel
- * buffer by FilterInputBytes(). Move the bytes back to their
- * original buffer because the caller could change the channel's
- * encoding which could change the interpretation of whether those
- * bytes really made up multi-byte characters after all.
+ * buffer by FilterInputBytes(). Move the bytes back to their original
+ * buffer because the caller could change the channel's encoding which
+ * could change the interpretation of whether those bytes really made
+ * up multi-byte characters after all.
*/
nextPtr = bufPtr->nextPtr;
@@ -4382,7 +4362,7 @@ CommonGetsCleanup(chanPtr, encoding)
*
* Tcl_Read --
*
- * Reads a given number of bytes from a channel. EOL and EOF translation
+ * Reads a given number of bytes from a channel. EOL and EOF translation
* is done on the bytes being read, so the number of bytes consumed from
* the channel may not be equal to the number of bytes stored in the
* destination buffer.
@@ -4400,10 +4380,10 @@ CommonGetsCleanup(chanPtr, encoding)
*/
int
-Tcl_Read(chan, dst, bytesToRead)
- Tcl_Channel chan; /* The channel from which to read. */
- char *dst; /* Where to store input read. */
- int bytesToRead; /* Maximum number of bytes to read. */
+Tcl_Read(
+ Tcl_Channel chan, /* The channel from which to read. */
+ char *dst, /* Where to store input read. */
+ int bytesToRead) /* Maximum number of bytes to read. */
{
Channel *chanPtr = (Channel *) chan;
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -4426,7 +4406,7 @@ Tcl_Read(chan, dst, bytesToRead)
*
* Tcl_ReadRaw --
*
- * Reads a given number of bytes from a channel. EOL and EOF translation
+ * Reads a given number of bytes from a channel. EOL and EOF translation
* is done on the bytes being read, so the number of bytes consumed from
* the channel may not be equal to the number of bytes stored in the
* destination buffer.
@@ -4444,10 +4424,10 @@ Tcl_Read(chan, dst, bytesToRead)
*/
int
-Tcl_ReadRaw(chan, bufPtr, bytesToRead)
- Tcl_Channel chan; /* The channel from which to read. */
- char *bufPtr; /* Where to store input read. */
- int bytesToRead; /* Maximum number of bytes to read. */
+Tcl_ReadRaw(
+ Tcl_Channel chan, /* The channel from which to read. */
+ char *bufPtr, /* Where to store input read. */
+ int bytesToRead) /* Maximum number of bytes to read. */
{
Channel *chanPtr = (Channel *) chan;
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -4514,8 +4494,8 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead)
/*
* 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).
+ * ourselves. The code was stolen from 'GetInput' and slightly
+ * adapted (different return value here).
*
* The case of 'bytesToRead == 0' at this point cannot happen.
*/
@@ -4588,11 +4568,11 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead)
* Tcl_ReadChars --
*
* Reads from the channel until the requested number of characters have
- * been seen, EOF is seen, or the channel would block. EOL and EOF
- * translation is done. If reading binary data, the raw bytes are
- * wrapped in a Tcl byte array object. Otherwise, the raw bytes are
- * converted to UTF-8 using the channel's current encoding and stored in
- * a Tcl string object.
+ * been seen, EOF is seen, or the channel would block. EOL and EOF
+ * translation is done. If reading binary data, the raw bytes are wrapped
+ * in a Tcl byte array object. Otherwise, the raw bytes are converted to
+ * UTF-8 using the channel's current encoding and stored in a Tcl string
+ * object.
*
* Results:
* The number of characters read, or -1 on error. Use Tcl_GetErrno() to
@@ -4605,14 +4585,14 @@ Tcl_ReadRaw(chan, bufPtr, bytesToRead)
*/
int
-Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
- Tcl_Channel chan; /* The channel to read. */
- Tcl_Obj *objPtr; /* Input data is stored in this object. */
- int toRead; /* Maximum number of characters to store, or
+Tcl_ReadChars(
+ Tcl_Channel chan, /* The channel to read. */
+ Tcl_Obj *objPtr, /* Input data is stored in this object. */
+ int toRead, /* Maximum number of characters to store, or
* -1 to read all available data (up to EOF or
* when channel blocks). */
- int appendFlag; /* If non-zero, data read from the channel
- * will be appended to the object. Otherwise,
+ int appendFlag) /* If non-zero, data read from the channel
+ * will be appended to the object. Otherwise,
* the data will replace the existing contents
* of the object. */
{
@@ -4643,11 +4623,11 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
* DoReadChars --
*
* Reads from the channel until the requested number of characters have
- * been seen, EOF is seen, or the channel would block. EOL and EOF
- * translation is done. If reading binary data, the raw bytes are
- * wrapped in a Tcl byte array object. Otherwise, the raw bytes are
- * converted to UTF-8 using the channel's current encoding and stored in
- * a Tcl string object.
+ * been seen, EOF is seen, or the channel would block. EOL and EOF
+ * translation is done. If reading binary data, the raw bytes are wrapped
+ * in a Tcl byte array object. Otherwise, the raw bytes are converted to
+ * UTF-8 using the channel's current encoding and stored in a Tcl string
+ * object.
*
* Results:
* The number of characters read, or -1 on error. Use Tcl_GetErrno() to
@@ -4660,14 +4640,14 @@ Tcl_ReadChars(chan, objPtr, toRead, appendFlag)
*/
static int
-DoReadChars(chanPtr, objPtr, toRead, appendFlag)
- Channel *chanPtr; /* The channel to read. */
- Tcl_Obj *objPtr; /* Input data is stored in this object. */
- int toRead; /* Maximum number of characters to store, or
+DoReadChars(
+ Channel *chanPtr, /* The channel to read. */
+ Tcl_Obj *objPtr, /* Input data is stored in this object. */
+ int toRead, /* Maximum number of characters to store, or
* -1 to read all available data (up to EOF or
* when channel blocks). */
- int appendFlag; /* If non-zero, data read from the channel
- * will be appended to the object. Otherwise,
+ int appendFlag) /* If non-zero, data read from the channel
+ * will be appended to the object. Otherwise,
* the data will replace the existing contents
* of the object. */
{
@@ -4775,14 +4755,15 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
UpdateInterest(chanPtr);
return copied;
}
+
/*
*---------------------------------------------------------------------------
*
* ReadBytes --
*
* Reads from the channel until the requested number of bytes have been
- * seen, EOF is seen, or the channel would block. Bytes from the channel
- * are stored in objPtr as a ByteArray object. EOL and EOF translation
+ * seen, EOF is seen, or the channel would block. Bytes from the channel
+ * are stored in objPtr as a ByteArray object. EOL and EOF translation
* are done.
*
* 'bytesToRead' can safely be a very large number because space is only
@@ -4801,22 +4782,22 @@ DoReadChars(chanPtr, objPtr, toRead, appendFlag)
*/
static int
-ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
- ChannelState *statePtr; /* State of the channel to read. */
- Tcl_Obj *objPtr; /* Input data is appended to this ByteArray
- * object. Its length is how much space has
+ReadBytes(
+ ChannelState *statePtr, /* State of the channel to read. */
+ Tcl_Obj *objPtr, /* Input data is appended to this ByteArray
+ * object. Its length is how much space has
* been allocated to hold data, not how many
* bytes of data have been stored in the
* object. */
- int bytesToRead; /* Maximum number of bytes to store, or < 0 to
+ int bytesToRead, /* Maximum number of bytes to store, or < 0 to
* get all available bytes. Bytes are obtained
* from the first buffer in the queue - even
* if this number is larger than the number of
* bytes available in the first buffer, only
* the bytes from the first buffer are
* returned. */
- int *offsetPtr; /* On input, contains how many bytes of objPtr
- * have been used to hold data. On output,
+ int *offsetPtr) /* On input, contains how many bytes of objPtr
+ * have been used to hold data. On output,
* filled with how many bytes are now being
* used. */
{
@@ -4902,13 +4883,13 @@ ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
*/
static int
-ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
- ChannelState *statePtr; /* State of channel to read. */
- Tcl_Obj *objPtr; /* Input data is appended to this object.
+ReadChars(
+ ChannelState *statePtr, /* State of channel to read. */
+ Tcl_Obj *objPtr, /* Input data is appended to this object.
* objPtr->length is how much space has been
* allocated to hold data, not how many bytes
* of data have been stored in the object. */
- int charsToRead; /* Maximum number of characters to store, or
+ int charsToRead, /* Maximum number of characters to store, or
* -1 to get all available characters.
* Characters are obtained from the first
* buffer in the queue -- even if this number
@@ -4916,14 +4897,14 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
* available in the first buffer, only the
* characters from the first buffer are
* returned. */
- int *offsetPtr; /* On input, contains how many bytes of objPtr
+ int *offsetPtr, /* On input, contains how many bytes of objPtr
* have been used to hold data. On output,
* filled with how many bytes are now being
* used. */
- int *factorPtr; /* On input, contains a guess of how many
+ int *factorPtr) /* On input, contains a guess of how many
* bytes need to be allocated to hold the
* result of converting N source bytes to
- * UTF-8. On output, contains another guess
+ * UTF-8. On output, contains another guess
* based on the data seen so far. */
{
int toRead, factor, offset, spaceLeft, length, srcLen, dstNeeded;
@@ -4946,7 +4927,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
/*
* 'factor' is how much we guess that the bytes in the source buffer will
- * expand when converted to UTF-8 chars. This guess comes from analyzing
+ * expand when converted to UTF-8 chars. This guess comes from analyzing
* how many characters were produced by the previous pass.
*/
@@ -4991,13 +4972,13 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars);
if ((dstWrote > 0) && (*dst == '\n')) {
/*
- * The next char was a '\n'. Consume it and produce a '\n'.
+ * The next char was a '\n'. Consume it and produce a '\n'.
*/
bufPtr->nextRemoved += srcRead;
} else {
/*
- * The next char was not a '\n'. Produce a '\r'.
+ * The next char was not a '\n'. Produce a '\r'.
*/
*dst = '\r';
@@ -5012,7 +4993,7 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars);
if (srcRead == 0) {
/*
- * Not enough bytes in src buffer to make a complete char. Copy the
+ * Not enough bytes in src buffer to make a complete char. Copy the
* bytes to the next buffer to make a new contiguous string, then tell
* the caller to fill the buffer with more bytes.
*/
@@ -5119,18 +5100,18 @@ ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
*/
static int
-TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
- ChannelState *statePtr; /* Channel being read, for EOL translation and
+TranslateInputEOL(
+ ChannelState *statePtr, /* Channel being read, for EOL translation and
* EOF character. */
- char *dstStart; /* Output buffer filled with chars by applying
+ char *dstStart, /* Output buffer filled with chars by applying
* appropriate EOL translation to source
* characters. */
- CONST char *srcStart; /* Source characters. */
- int *dstLenPtr; /* On entry, the maximum length of output
+ CONST char *srcStart, /* Source characters. */
+ int *dstLenPtr, /* On entry, the maximum length of output
* buffer in bytes; must be <= *srcLenPtr. On
* exit, the number of bytes actually used in
* output buffer. */
- int *srcLenPtr; /* On entry, the length of source buffer. On
+ int *srcLenPtr) /* On entry, the length of source buffer. On
* exit, the number of bytes read from the
* source buffer. */
{
@@ -5255,7 +5236,7 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
if ((eof != NULL) && (srcStart + srcLen >= eof)) {
/*
- * EOF character was seen in EOL translated range. Leave current file
+ * EOF character was seen in EOL translated range. Leave current file
* position pointing at the EOF character, but don't store the EOF
* character in the output string.
*/
@@ -5288,11 +5269,11 @@ TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
*/
int
-Tcl_Ungets(chan, str, len, atEnd)
- Tcl_Channel chan; /* The channel for which to add the input. */
- CONST char *str; /* The input itself. */
- int len; /* The length of the input. */
- int atEnd; /* If non-zero, add at end of queue; otherwise
+Tcl_Ungets(
+ Tcl_Channel chan, /* The channel for which to add the input. */
+ CONST char *str, /* The input itself. */
+ int len, /* The length of the input. */
+ int atEnd) /* If non-zero, add at end of queue; otherwise
* add at head of queue. */
{
Channel *chanPtr; /* The real IO channel. */
@@ -5337,12 +5318,12 @@ Tcl_Ungets(chan, str, len, atEnd)
bufPtr->buf[bufPtr->nextAdded++] = str[i];
}
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ if (statePtr->inQueueHead == NULL) {
+ bufPtr->nextPtr = NULL;
statePtr->inQueueHead = bufPtr;
statePtr->inQueueTail = bufPtr;
} else if (atEnd) {
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
statePtr->inQueueTail->nextPtr = bufPtr;
statePtr->inQueueTail = bufPtr;
} else {
@@ -5377,12 +5358,14 @@ Tcl_Ungets(chan, str, len, atEnd)
*/
int
-Tcl_Flush(chan)
- Tcl_Channel chan; /* The Channel to flush. */
+Tcl_Flush(
+ Tcl_Channel chan) /* The Channel to flush. */
{
- int result; /* Of calling FlushChannel. */
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
- ChannelState *statePtr = chanPtr->state; /* State of actual channel. */
+ int result; /* Of calling FlushChannel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State of actual channel. */
/*
* This operation should occur at the top of a channel stack.
@@ -5431,18 +5414,18 @@ Tcl_Flush(chan)
*/
static void
-DiscardInputQueued(statePtr, discardSavedBuffers)
- ChannelState *statePtr; /* Channel on which to discard the queued
+DiscardInputQueued(
+ ChannelState *statePtr, /* Channel on which to discard the queued
* input. */
- int discardSavedBuffers; /* If non-zero, discard all buffers including
+ int discardSavedBuffers) /* If non-zero, discard all buffers including
* last one. */
{
ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
bufPtr = statePtr->inQueueHead;
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
- for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
+ for (; bufPtr != NULL; bufPtr = nxtPtr) {
nxtPtr = bufPtr->nextPtr;
RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
}
@@ -5452,11 +5435,9 @@ DiscardInputQueued(statePtr, discardSavedBuffers)
* saved buffer in the saveInBufPtr field.
*/
- if (discardSavedBuffers) {
- if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) {
- ckfree((char *) statePtr->saveInBufPtr);
- statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
- }
+ if (discardSavedBuffers && statePtr->saveInBufPtr != NULL) {
+ ckfree((char *) statePtr->saveInBufPtr);
+ statePtr->saveInBufPtr = NULL;
}
}
@@ -5478,8 +5459,8 @@ DiscardInputQueued(statePtr, discardSavedBuffers)
*/
static int
-GetInput(chanPtr)
- Channel *chanPtr; /* Channel to read input from. */
+GetInput(
+ Channel *chanPtr) /* Channel to read input from. */
{
int toRead; /* How much to read? */
int result; /* Of calling driver. */
@@ -5508,16 +5489,16 @@ GetInput(chanPtr)
* buffer. In the latter case we can recycle it now.
*/
- if (chanPtr->inQueueHead != (ChannelBuffer *) NULL) {
- if (statePtr->inQueueHead != (ChannelBuffer *) NULL) {
+ if (chanPtr->inQueueHead != NULL) {
+ if (statePtr->inQueueHead != NULL) {
RecycleBuffer(statePtr, statePtr->inQueueHead, 0);
- statePtr->inQueueHead = (ChannelBuffer *) NULL;
+ statePtr->inQueueHead = NULL;
}
statePtr->inQueueHead = chanPtr->inQueueHead;
statePtr->inQueueTail = chanPtr->inQueueTail;
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
return 0;
}
@@ -5555,7 +5536,7 @@ GetInput(chanPtr)
if (bufPtr == NULL) {
bufPtr = AllocChannelBuffer(statePtr->bufSize);
}
- bufPtr->nextPtr = (ChannelBuffer *) NULL;
+ bufPtr->nextPtr = NULL;
/*
* SF #427196: Use the actual size of the buffer to determine the
@@ -5675,10 +5656,10 @@ GetInput(chanPtr)
*/
Tcl_WideInt
-Tcl_Seek(chan, offset, mode)
- Tcl_Channel chan; /* The channel on which to seek. */
- Tcl_WideInt offset; /* Offset to seek to. */
- int mode; /* Relative to which location to seek? */
+Tcl_Seek(
+ Tcl_Channel chan, /* The channel on which to seek. */
+ Tcl_WideInt offset, /* Offset to seek to. */
+ int mode) /* Relative to which location to seek? */
{
Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -5716,7 +5697,7 @@ Tcl_Seek(chan, offset, mode)
* defined. This means that the channel does not support seeking.
*/
- if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
+ if (chanPtr->typePtr->seekProc == NULL) {
Tcl_SetErrno(EINVAL);
return Tcl_LongAsWide(-1);
}
@@ -5783,7 +5764,7 @@ Tcl_Seek(chan, offset, mode)
* as ready to flush before invoking FlushChannel.
*/
- if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
+ if ((statePtr->curOutPtr != NULL) &&
(statePtr->curOutPtr->nextAdded >
statePtr->curOutPtr->nextRemoved)) {
statePtr->flags |= BUFFER_READY;
@@ -5793,17 +5774,16 @@ Tcl_Seek(chan, offset, mode)
* If the flush fails we cannot recover the original position. In that
* case the seek is not attempted because we do not know where the access
* position is - instead we return the error. FlushChannel has already
- * called Tcl_SetErrno() to report the error upwards. If the flush
+ * called Tcl_SetErrno() to report the error upwards. If the flush
* succeeds we do the seek also.
*/
if (FlushChannel(NULL, chanPtr, 0) != 0) {
curPos = -1;
} else {
-
/*
* Now seek to the new position in the channel as requested by the
- * caller. Note that we prefer the wideSeekProc if that is available
+ * caller. Note that we prefer the wideSeekProc if that is available
* and non-NULL...
*/
@@ -5863,14 +5843,15 @@ Tcl_Seek(chan, offset, mode)
*/
Tcl_WideInt
-Tcl_Tell(chan)
- Tcl_Channel chan; /* The channel to return pos for. */
+Tcl_Tell(
+ Tcl_Channel chan) /* The channel to return pos for. */
{
Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
ChannelState *statePtr = chanPtr->state; /* state info for channel */
- int inputBuffered, outputBuffered; /* # bytes held in buffers. */
- int result; /* Of calling device driver. */
- Tcl_WideInt curPos; /* Position on device. */
+ int inputBuffered, outputBuffered;
+ /* # bytes held in buffers. */
+ int result; /* Of calling device driver. */
+ Tcl_WideInt curPos; /* Position on device. */
if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
return Tcl_LongAsWide(-1);
@@ -5898,7 +5879,7 @@ Tcl_Tell(chan)
* defined. This means that the channel does not support seeking.
*/
- if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
+ if (chanPtr->typePtr->seekProc == NULL) {
Tcl_SetErrno(EINVAL);
return Tcl_LongAsWide(-1);
}
@@ -5918,7 +5899,7 @@ Tcl_Tell(chan)
/*
* Get the current position in the device and compute the position where
- * the next character will be read or written. Note that we prefer the
+ * the next character will be read or written. Note that we prefer the
* wideSeekProc if that is available and non-NULL...
*/
@@ -5946,7 +5927,7 @@ Tcl_Tell(chan)
* Tcl_SeekOld, Tcl_TellOld --
*
* Backward-compatability versions of the seek/tell interface that do not
- * support 64-bit offsets. This interface is not documented or expected
+ * support 64-bit offsets. This interface is not documented or expected
* to be supported indefinitely.
*
* Results:
@@ -5960,10 +5941,10 @@ Tcl_Tell(chan)
*/
int
-Tcl_SeekOld(chan, offset, mode)
- Tcl_Channel chan; /* The channel on which to seek. */
- int offset; /* Offset to seek to. */
- int mode; /* Relative to which location to seek? */
+Tcl_SeekOld(
+ Tcl_Channel chan, /* The channel on which to seek. */
+ int offset, /* Offset to seek to. */
+ int mode) /* Relative to which location to seek? */
{
Tcl_WideInt wOffset, wResult;
@@ -5973,8 +5954,8 @@ Tcl_SeekOld(chan, offset, mode)
}
int
-Tcl_TellOld(chan)
- Tcl_Channel chan; /* The channel to return pos for. */
+Tcl_TellOld(
+ Tcl_Channel chan) /* The channel to return pos for. */
{
Tcl_WideInt wResult;
@@ -6001,9 +5982,9 @@ Tcl_TellOld(chan)
*/
int
-Tcl_TruncateChannel(chan, length)
- Tcl_Channel chan;
- Tcl_WideInt length;
+Tcl_TruncateChannel(
+ Tcl_Channel chan, /* Channel to truncate. */
+ Tcl_WideInt length) /* Length to truncate it to. */
{
Channel *chanPtr = (Channel *) chan;
Tcl_DriverTruncateProc *truncateProc =
@@ -6069,10 +6050,10 @@ Tcl_TruncateChannel(chan, length)
*/
static int
-CheckChannelErrors(statePtr, flags)
- ChannelState *statePtr; /* Channel to check. */
- int flags; /* Test if channel supports desired operation:
- * TCL_READABLE, TCL_WRITABLE. Also indicates
+CheckChannelErrors(
+ ChannelState *statePtr, /* Channel to check. */
+ int flags) /* Test if channel supports desired operation:
+ * TCL_READABLE, TCL_WRITABLE. Also indicates
* Raw read or write for special close
* processing */
{
@@ -6086,14 +6067,15 @@ CheckChannelErrors(statePtr, flags)
Tcl_SetErrno(statePtr->unreportedError);
statePtr->unreportedError = 0;
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move a defered error message back into the channel bypass.
*/
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount (statePtr->chanMsg);
+ Tcl_DecrRefCount(statePtr->chanMsg);
}
- statePtr->chanMsg = statePtr->unreportedMsg;
+ statePtr->chanMsg = statePtr->unreportedMsg;
statePtr->unreportedMsg = NULL;
return -1;
}
@@ -6165,11 +6147,11 @@ CheckChannelErrors(statePtr, flags)
*/
int
-Tcl_Eof(chan)
- Tcl_Channel chan; /* Does this channel have EOF? */
+Tcl_Eof(
+ Tcl_Channel chan) /* Does this channel have EOF? */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return ((statePtr->flags & CHANNEL_STICKY_EOF) ||
((statePtr->flags & CHANNEL_EOF) &&
@@ -6193,11 +6175,11 @@ Tcl_Eof(chan)
*/
int
-Tcl_InputBlocked(chan)
- Tcl_Channel chan; /* Is this channel blocked? */
+Tcl_InputBlocked(
+ Tcl_Channel chan) /* Is this channel blocked? */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
}
@@ -6221,16 +6203,15 @@ Tcl_InputBlocked(chan)
*/
int
-Tcl_InputBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_InputBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
- for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
+ for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; bufPtr != NULL;
bufPtr = bufPtr->nextPtr) {
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
@@ -6239,8 +6220,7 @@ Tcl_InputBuffered(chan)
* Don't forget the bytes in the topmost pushback area.
*/
- for (bufPtr = statePtr->topChanPtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
+ for (bufPtr = statePtr->topChanPtr->inQueueHead; bufPtr != NULL;
bufPtr = bufPtr->nextPtr) {
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
@@ -6267,23 +6247,24 @@ Tcl_InputBuffered(chan)
*/
int
-Tcl_OutputBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_OutputBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
/* State of real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
- for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
- bufPtr = bufPtr->nextPtr) {
+ for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL;
+ bufPtr = bufPtr->nextPtr) {
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
- if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
- (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
- bytesBuffered +=
- (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
+ if (statePtr->curOutPtr != NULL) {
+ register ChannelBuffer *curOutPtr = statePtr->curOutPtr;
+
+ if {curOutPtr->nextAdded > curOutPtr->nextRemoved) {
+ bytesBuffered += curOutPtr->nextAdded - curOutPtr->nextRemoved;
+ }
}
return bytesBuffered;
@@ -6308,16 +6289,15 @@ Tcl_OutputBuffered(chan)
*/
int
-Tcl_ChannelBuffered(chan)
- Tcl_Channel chan; /* The channel to query. */
+Tcl_ChannelBuffered(
+ Tcl_Channel chan) /* The channel to query. */
{
Channel *chanPtr = (Channel *) chan;
- /* real channel structure. */
+ /* real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
- for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
- bufPtr != (ChannelBuffer *) NULL;
+ for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead; bufPtr != NULL;
bufPtr = bufPtr->nextPtr) {
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
}
@@ -6343,12 +6323,11 @@ Tcl_ChannelBuffered(chan)
*/
void
-Tcl_SetChannelBufferSize(chan, sz)
- Tcl_Channel chan; /* The channel whose buffer size to
- * set. */
- int sz; /* The size to set. */
+Tcl_SetChannelBufferSize(
+ Tcl_Channel chan, /* The channel whose buffer size to set. */
+ int sz) /* The size to set. */
{
- ChannelState *statePtr; /* State of real channel structure. */
+ ChannelState *statePtr; /* State of real channel structure. */
/*
* If the buffer size is smaller than 1 byte or larger than one MByte, do
@@ -6392,12 +6371,12 @@ Tcl_SetChannelBufferSize(chan, sz)
*/
int
-Tcl_GetChannelBufferSize(chan)
- Tcl_Channel chan; /* The channel for which to find the
- * buffer size. */
+Tcl_GetChannelBufferSize(
+ Tcl_Channel chan) /* The channel for which to find the buffer
+ * size. */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return statePtr->bufSize;
}
@@ -6408,7 +6387,7 @@ Tcl_GetChannelBufferSize(chan)
* Tcl_BadChannelOption --
*
* This procedure generates a "bad option" error message in an (optional)
- * interpreter. It is used by channel drivers when a invalid Set/Get
+ * interpreter. It is used by channel drivers when a invalid Set/Get
* option is requested. Its purpose is to concatenate the generic options
* list to the specific ones and factorize the generic options error
* message string.
@@ -6419,12 +6398,12 @@ Tcl_GetChannelBufferSize(chan)
* Side effects:
* An error message is generated in interp's result object to indicate
- * that a command was invoked with the a bad option. The message has the
+ * that a command was invoked with the a bad option. The message has the
* form:
* bad option "blah": should be one of
* <...generic options...>+<...specific options...>
* "blah" is the optionName argument and "<specific options>" is a space
- * separated list of specific option words. The function takes good care
+ * separated list of specific option words. The function takes good care
* of inserting minus signs before each option, commas after, and an "or"
* before the last option.
*
@@ -6432,13 +6411,12 @@ Tcl_GetChannelBufferSize(chan)
*/
int
-Tcl_BadChannelOption(interp, optionName, optionList)
- Tcl_Interp *interp; /* Current interpreter (can be NULL).*/
- CONST char *optionName; /* 'bad option' name */
- CONST char *optionList; /* Specific options list to append to
- * the standard generic options. Can
- * be NULL for generic options
- * only. */
+Tcl_BadChannelOption(
+ Tcl_Interp *interp, /* Current interpreter (can be NULL).*/
+ CONST char *optionName, /* 'bad option' name */
+ CONST char *optionList) /* Specific options list to append to the
+ * standard generic options. Can be NULL for
+ * generic options only. */
{
if (interp != NULL) {
CONST char *genericopt =
@@ -6459,12 +6437,12 @@ Tcl_BadChannelOption(interp, optionName, optionList)
}
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "bad option \"", optionName,
- "\": should be one of ", (char *) NULL);
+ "\": should be one of ", NULL);
argc--;
for (i = 0; i < argc; i++) {
- Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
+ Tcl_AppendResult(interp, "-", argv[i], ", ", NULL);
}
- Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL);
+ Tcl_AppendResult(interp, "or -", argv[i], NULL);
Tcl_DStringFree(&ds);
ckfree((char *) argv);
}
@@ -6493,11 +6471,11 @@ Tcl_BadChannelOption(interp, optionName, optionList)
*/
int
-Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
- Tcl_Interp *interp; /* For error reporting - can be NULL. */
- Tcl_Channel chan; /* Channel on which to get option. */
- CONST char *optionName; /* Option to get. */
- Tcl_DString *dsPtr; /* Where to store value(s). */
+Tcl_GetChannelOption(
+ Tcl_Interp *interp, /* For error reporting - can be NULL. */
+ Tcl_Channel chan, /* Channel on which to get option. */
+ CONST char *optionName, /* Option to get. */
+ Tcl_DString *dsPtr) /* Where to store value(s). */
{
size_t len; /* Length of optionName string. */
char optionVal[128]; /* Buffer for sprintf. */
@@ -6541,7 +6519,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
* and values.
*/
- if (optionName == (char *) NULL) {
+ if (optionName == NULL) {
len = 0;
} else {
len = strlen(optionName);
@@ -6690,7 +6668,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
return TCL_OK;
}
}
- if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) {
+ if (chanPtr->typePtr->getOptionProc != NULL) {
/*
* Let the driver specific handle additional options and result code
* and message.
@@ -6718,7 +6696,7 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
* Sets an option on a channel.
*
* Results:
- * A standard Tcl result. On error, sets interp's result object if
+ * A standard Tcl result. On error, sets interp's result object if
* interp is not NULL.
*
* Side effects:
@@ -6728,11 +6706,11 @@ Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
*/
int
-Tcl_SetChannelOption(interp, chan, optionName, newValue)
- Tcl_Interp *interp; /* For error reporting - can be NULL. */
- Tcl_Channel chan; /* Channel on which to set mode. */
- CONST char *optionName; /* Which option to set? */
- CONST char *newValue; /* New value for option. */
+Tcl_SetChannelOption(
+ Tcl_Interp *interp, /* For error reporting - can be NULL. */
+ Tcl_Channel chan, /* Channel on which to set mode. */
+ CONST char *optionName, /* Which option to set? */
+ CONST char *newValue) /* New value for option. */
{
Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -6747,7 +6725,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
if (statePtr->csPtr) {
if (interp) {
Tcl_AppendResult(interp, "unable to set channel options: ",
- "background copy in progress", (char *) NULL);
+ "background copy in progress", NULL);
}
return TCL_ERROR;
}
@@ -6800,8 +6778,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
} else {
if (interp) {
Tcl_AppendResult(interp, "bad value for -buffering: ",
- "must be one of full, line, or none",
- (char *) NULL);
+ "must be one of full, line, or none", NULL);
return TCL_ERROR;
}
}
@@ -6863,7 +6840,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
if (interp) {
Tcl_AppendResult(interp,
"bad value for -eofchar: should be a list of zero,",
- " one, or two elements", (char *) NULL);
+ " one, or two elements", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
@@ -6907,7 +6884,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
if (interp) {
Tcl_AppendResult(interp,
"bad value for -translation: must be a one or two",
- " element list", (char *) NULL);
+ " element list", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
@@ -6937,7 +6914,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
Tcl_AppendResult(interp,
"bad value for -translation: ",
"must be one of auto, binary, cr, lf, crlf,",
- " or platform", (char *) NULL);
+ " or platform", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
@@ -6962,7 +6939,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
} else if (strcmp(writeMode, "auto") == 0) {
/*
* This is a hack to get TCP sockets to produce output in CRLF
- * mode if they are being set into AUTO mode. A better
+ * mode if they are being set into AUTO mode. A better
* solution for achieving this effect will be coded later.
*/
@@ -6989,7 +6966,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
Tcl_AppendResult(interp,
"bad value for -translation: ",
"must be one of auto, binary, cr, lf, crlf,",
- " or platform", (char *) NULL);
+ " or platform", NULL);
}
ckfree((char *) argv);
return TCL_ERROR;
@@ -7001,7 +6978,7 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData,
interp, optionName, newValue);
} else {
- return Tcl_BadChannelOption(interp, optionName, (char *) NULL);
+ return Tcl_BadChannelOption(interp, optionName, NULL);
}
/*
@@ -7057,9 +7034,9 @@ Tcl_SetChannelOption(interp, chan, optionName, newValue)
*/
static void
-CleanupChannelHandlers(interp, chanPtr)
- Tcl_Interp *interp;
- Channel *chanPtr;
+CleanupChannelHandlers(
+ Tcl_Interp *interp,
+ Channel *chanPtr)
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
@@ -7069,13 +7046,11 @@ CleanupChannelHandlers(interp, chanPtr)
* interpreter.
*/
- for (sPtr = statePtr->scriptRecordPtr,
- prevPtr = (EventScriptRecord *) NULL;
- sPtr != (EventScriptRecord *) NULL;
- sPtr = nextPtr) {
+ for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+ sPtr != NULL; sPtr = nextPtr) {
nextPtr = sPtr->nextPtr;
if (sPtr->interp == interp) {
- if (prevPtr == (EventScriptRecord *) NULL) {
+ if (prevPtr == NULL) {
statePtr->scriptRecordPtr = nextPtr;
} else {
prevPtr->nextPtr = nextPtr;
@@ -7098,7 +7073,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 for actually
+ * event on a channel. This procedure is responsible for actually
* handling the event by invoking any channel handler callbacks.
*
* Results:
@@ -7111,9 +7086,9 @@ CleanupChannelHandlers(interp, chanPtr)
*/
void
-Tcl_NotifyChannel(channel, mask)
- Tcl_Channel channel; /* Channel that detected an event. */
- int mask; /* OR'ed combination of TCL_READABLE,
+Tcl_NotifyChannel(
+ Tcl_Channel channel, /* Channel that detected an event. */
+ int mask) /* OR'ed combination of TCL_READABLE,
* TCL_WRITABLE, or TCL_EXCEPTION: indicates
* which events were detected. */
{
@@ -7136,7 +7111,6 @@ Tcl_NotifyChannel(channel, mask)
(statePtr->flags & CHANNEL_NONBLOCKING) &&
(Tcl_ChannelBlockModeProc(chanPtr->typePtr) == NULL) &&
!(statePtr->flags & CHANNEL_TIMER_FEV)) {
-
statePtr->flags |= CHANNEL_HAS_MORE_DATA;
}
#endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
@@ -7153,7 +7127,7 @@ Tcl_NotifyChannel(channel, mask)
* their own events and pass them upward.
*/
- while (mask && (chanPtr->upChanPtr != ((Channel *) NULL))) {
+ while (mask && (chanPtr->upChanPtr != (NULL))) {
Tcl_DriverHandlerProc *upHandlerProc;
upChanPtr = chanPtr->upChanPtr;
@@ -7195,7 +7169,7 @@ Tcl_NotifyChannel(channel, mask)
/*
* 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
+ * writable events. Note that we have to discard the writable event so we
* don't call any write handlers before the flush is complete.
*/
@@ -7209,11 +7183,11 @@ Tcl_NotifyChannel(channel, mask)
* ChannelHandlerEventProc.
*/
- nh.nextHandlerPtr = (ChannelHandler *) NULL;
+ nh.nextHandlerPtr = NULL;
nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
tsdPtr->nestedHandlerPtr = &nh;
- for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; ) {
/*
* If this channel handler is interested in any of the events that
* have occurred on the channel, invoke its procedure.
@@ -7262,8 +7236,8 @@ Tcl_NotifyChannel(channel, mask)
*/
static void
-UpdateInterest(chanPtr)
- Channel *chanPtr; /* Channel to update. */
+UpdateInterest(
+ Channel *chanPtr) /* Channel to update. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
int mask = statePtr->interestMask;
@@ -7280,13 +7254,13 @@ UpdateInterest(chanPtr)
/*
* If there is data in the input queue, and we aren't waiting for more
* data, then we need to schedule a timer so we don't block in the
- * notifier. Also, cancel the read interest so we don't get duplicate
+ * notifier. Also, cancel the read interest so we don't get duplicate
* events.
*/
if (mask & TCL_READABLE) {
if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
- && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+ && (statePtr->inQueueHead != NULL)
&& (statePtr->inQueueHead->nextRemoved <
statePtr->inQueueHead->nextAdded)) {
mask &= ~TCL_READABLE;
@@ -7358,15 +7332,15 @@ UpdateInterest(chanPtr)
*/
static void
-ChannelTimerProc(clientData)
- ClientData clientData;
+ChannelTimerProc(
+ ClientData clientData)
{
Channel *chanPtr = (Channel *) clientData;
ChannelState *statePtr = chanPtr->state; /* state info for channel */
if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
&& (statePtr->interestMask & TCL_READABLE)
- && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
+ && (statePtr->inQueueHead != NULL)
&& (statePtr->inQueueHead->nextRemoved <
statePtr->inQueueHead->nextAdded)) {
/*
@@ -7428,16 +7402,16 @@ ChannelTimerProc(clientData)
*/
void
-Tcl_CreateChannelHandler(chan, mask, proc, clientData)
- Tcl_Channel chan; /* The channel to create the handler for. */
- int mask; /* OR'ed combination of TCL_READABLE,
+Tcl_CreateChannelHandler(
+ Tcl_Channel chan, /* The channel to create the handler for. */
+ int mask, /* OR'ed combination of TCL_READABLE,
* TCL_WRITABLE, and TCL_EXCEPTION: indicates
* conditions under which proc should be
* called. Use 0 to disable a registered
* handler. */
- Tcl_ChannelProc *proc; /* Procedure to call for each selected
+ Tcl_ChannelProc *proc, /* Procedure to call for each selected
* event. */
- ClientData clientData; /* Arbitrary data to pass to proc. */
+ ClientData clientData) /* Arbitrary data to pass to proc. */
{
ChannelHandler *chPtr;
Channel *chanPtr = (Channel *) chan;
@@ -7449,16 +7423,14 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
* values).
*/
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
(chPtr->clientData == clientData)) {
break;
}
}
- if (chPtr == (ChannelHandler *) NULL) {
- chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
+ if (chPtr == NULL) {
+ chPtr = (ChannelHandler *) ckalloc(sizeof(ChannelHandler));
chPtr->mask = 0;
chPtr->proc = proc;
chPtr->clientData = clientData;
@@ -7480,9 +7452,7 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
*/
statePtr->interestMask = 0;
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
statePtr->interestMask |= chPtr->mask;
}
@@ -7508,11 +7478,11 @@ Tcl_CreateChannelHandler(chan, mask, proc, clientData)
*/
void
-Tcl_DeleteChannelHandler(chan, proc, clientData)
- Tcl_Channel chan; /* The channel for which to remove the
+Tcl_DeleteChannelHandler(
+ Tcl_Channel chan, /* The channel for which to remove the
* callback. */
- Tcl_ChannelProc *proc; /* The procedure in the callback to delete. */
- ClientData clientData; /* The client data in the callback to
+ Tcl_ChannelProc *proc, /* The procedure in the callback to delete. */
+ ClientData clientData) /* The client data in the callback to
* delete. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -7525,8 +7495,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* Find the entry and the previous one in the list.
*/
- for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
+ for (prevChPtr = NULL, chPtr = statePtr->chPtr; chPtr != NULL;
chPtr = chPtr->nextPtr) {
if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
&& (chPtr->proc == proc)) {
@@ -7539,7 +7508,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* If not found, return without doing anything.
*/
- if (chPtr == (ChannelHandler *) NULL) {
+ if (chPtr == NULL) {
return;
}
@@ -7548,8 +7517,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* process the next one instead - we are going to delete *this* one.
*/
- for (nhPtr = tsdPtr->nestedHandlerPtr;
- nhPtr != (NextChannelHandler *) NULL;
+ for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
nhPtr = nhPtr->nestedHandlerPtr) {
if (nhPtr->nextHandlerPtr == chPtr) {
nhPtr->nextHandlerPtr = chPtr->nextPtr;
@@ -7560,7 +7528,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
* Splice it out of the list of channel handlers.
*/
- if (prevChPtr == (ChannelHandler *) NULL) {
+ if (prevChPtr == NULL) {
statePtr->chPtr = chPtr->nextPtr;
} else {
prevChPtr->nextPtr = chPtr->nextPtr;
@@ -7573,9 +7541,7 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
*/
statePtr->interestMask = 0;
- for (chPtr = statePtr->chPtr;
- chPtr != (ChannelHandler *) NULL;
- chPtr = chPtr->nextPtr) {
+ for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
statePtr->interestMask |= chPtr->mask;
}
@@ -7600,20 +7566,18 @@ Tcl_DeleteChannelHandler(chan, proc, clientData)
*/
static void
-DeleteScriptRecord(interp, chanPtr, mask)
- Tcl_Interp *interp; /* Interpreter in which script was to be
+DeleteScriptRecord(
+ Tcl_Interp *interp, /* Interpreter in which script was to be
* executed. */
- Channel *chanPtr; /* The channel for which to delete the script
+ Channel *chanPtr, /* The channel for which to delete the script
* record (if any). */
- int mask; /* Events in mask must exactly match mask of
+ int mask) /* Events in mask must exactly match mask of
* script to delete. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *esPtr, *prevEsPtr;
- for (esPtr = statePtr->scriptRecordPtr,
- prevEsPtr = (EventScriptRecord *) NULL;
- esPtr != (EventScriptRecord *) NULL;
+ for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL;
prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
if (esPtr == statePtr->scriptRecordPtr) {
@@ -7651,30 +7615,26 @@ DeleteScriptRecord(interp, chanPtr, mask)
*/
static void
-CreateScriptRecord(interp, chanPtr, mask, scriptPtr)
- Tcl_Interp *interp; /* Interpreter in which to execute the
- * stored script. */
- Channel *chanPtr; /* Channel for which script is to be
- * stored. */
- int mask; /* Set of events for which script will
- * be invoked. */
- Tcl_Obj *scriptPtr; /* Pointer to script object. */
+CreateScriptRecord(
+ Tcl_Interp *interp, /* Interpreter in which to execute the stored
+ * script. */
+ Channel *chanPtr, /* Channel for which script is to be stored */
+ int mask, /* Set of events for which script will be
+ * invoked. */
+ Tcl_Obj *scriptPtr) /* Pointer to script object. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
EventScriptRecord *esPtr;
- for (esPtr = statePtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
- esPtr = esPtr->nextPtr) {
+ for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
TclDecrRefCount(esPtr->scriptPtr);
- esPtr->scriptPtr = (Tcl_Obj *) NULL;
+ esPtr->scriptPtr = NULL;
break;
}
}
- if (esPtr == (EventScriptRecord *) NULL) {
- esPtr = (EventScriptRecord *)
- ckalloc((unsigned) sizeof(EventScriptRecord));
+ if (esPtr == NULL) {
+ esPtr = (EventScriptRecord *) ckalloc(sizeof(EventScriptRecord));
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
TclChannelEventScriptInvoker, (ClientData) esPtr);
esPtr->nextPtr = statePtr->scriptRecordPtr;
@@ -7706,9 +7666,9 @@ CreateScriptRecord(interp, chanPtr, mask, scriptPtr)
*/
void
-TclChannelEventScriptInvoker(clientData, mask)
- ClientData clientData; /* The script+interp record. */
- int mask; /* Not used. */
+TclChannelEventScriptInvoker(
+ ClientData clientData, /* The script+interp record. */
+ int mask) /* Not used. */
{
Tcl_Interp *interp; /* Interpreter in which to eval the script. */
Channel *chanPtr; /* The channel for which this handler is
@@ -7769,20 +7729,18 @@ TclChannelEventScriptInvoker(clientData, mask)
/* ARGSUSED */
int
-Tcl_FileEventObjCmd(clientData, interp, objc, objv)
- ClientData clientData; /* Not used. */
- Tcl_Interp *interp; /* Interpreter in which the channel
- * for which to create the handler is
- * found. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
-{
- Channel *chanPtr; /* The channel to create the handler
- * for. */
- ChannelState *statePtr; /* state info for channel */
- Tcl_Channel chan; /* The opaque type for the channel. */
+Tcl_FileEventObjCmd(
+ ClientData clientData, /* Not used. */
+ Tcl_Interp *interp, /* Interpreter in which the channel for which
+ * to create the handler is found. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
+{
+ Channel *chanPtr; /* The channel to create the handler for. */
+ ChannelState *statePtr; /* state info for channel */
+ Tcl_Channel chan; /* The opaque type for the channel. */
char *chanName;
- int modeIndex; /* Index of mode argument. */
+ int modeIndex; /* Index of mode argument. */
int mask;
static CONST char *modeOptions[] = {"readable", "writable", NULL};
static int maskArray[] = {TCL_READABLE, TCL_WRITABLE};
@@ -7806,8 +7764,7 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
statePtr = chanPtr->state;
if ((statePtr->flags & mask) == 0) {
Tcl_AppendResult(interp, "channel is not ",
- (mask == TCL_READABLE) ? "readable" : "writable",
- (char *) NULL);
+ (mask == TCL_READABLE) ? "readable" : "writable", NULL);
return TCL_ERROR;
}
@@ -7817,8 +7774,7 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
if (objc == 3) {
EventScriptRecord *esPtr;
- for (esPtr = statePtr->scriptRecordPtr;
- esPtr != (EventScriptRecord *) NULL;
+ for (esPtr = statePtr->scriptRecordPtr; esPtr != NULL;
esPtr = esPtr->nextPtr) {
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
Tcl_SetObjResult(interp, esPtr->scriptPtr);
@@ -7854,9 +7810,9 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
* TclCopyChannel --
*
* This routine copies data from one channel to another, either
- * synchronously or asynchronously. If a command script is supplied, the
- * operation runs in the background. The script is invoked when the copy
- * completes. Otherwise the function waits until the copy is completed
+ * synchronously or asynchronously. If a command script is supplied, the
+ * operation runs in the background. The script is invoked when the copy
+ * completes. Otherwise the function waits until the copy is completed
* before returning.
*
* Results:
@@ -7870,12 +7826,12 @@ Tcl_FileEventObjCmd(clientData, interp, objc, objv)
*/
int
-TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
- Tcl_Interp *interp; /* Current interpreter. */
- Tcl_Channel inChan; /* Channel to read from. */
- Tcl_Channel outChan; /* Channel to write to. */
- int toRead; /* Amount of data to copy, or -1 for all. */
- Tcl_Obj *cmdPtr; /* Pointer to script to execute or NULL. */
+TclCopyChannel(
+ Tcl_Interp *interp, /* Current interpreter. */
+ Tcl_Channel inChan, /* Channel to read from. */
+ Tcl_Channel outChan, /* Channel to write to. */
+ int toRead, /* Amount of data to copy, or -1 for all. */
+ Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */
{
Channel *inPtr = (Channel *) inChan;
Channel *outPtr = (Channel *) outChan;
@@ -7902,31 +7858,24 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
writeFlags = outStatePtr->flags;
/*
- * Set up the blocking mode appropriately. Background copies need
- * non-blocking channels. Foreground copies need blocking channels. If
+ * Set up the blocking mode appropriately. Background copies need
+ * non-blocking channels. Foreground copies need blocking channels. If
* there is an error, restore the old blocking mode.
*/
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
- if (SetBlockMode(interp, inPtr,
- nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
- != TCL_OK) {
+ if (SetBlockMode(interp, inPtr, nonBlocking ?
+ TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) {
return TCL_ERROR;
}
}
- if (inPtr != outPtr) {
- if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) {
- if (SetBlockMode(NULL, outPtr,
- nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
- != TCL_OK) {
- if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
- SetBlockMode(NULL, inPtr,
- (readFlags & CHANNEL_NONBLOCKING)
- ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
- return TCL_ERROR;
- }
- }
- }
+ if ((inPtr!=outPtr) && (nonBlocking!=(writeFlags&CHANNEL_NONBLOCKING)) &&
+ (SetBlockMode(NULL, outPtr, nonBlocking ?
+ TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) &&
+ (nonBlocking != (readFlags & CHANNEL_NONBLOCKING))) {
+ SetBlockMode(NULL, inPtr, (readFlags & CHANNEL_NONBLOCKING)
+ ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
+ return TCL_ERROR;
}
/*
@@ -7938,7 +7887,7 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
/*
* Allocate a new CopyState to maintain info about the current copy in
- * progress. This structure will be deallocated when the copy is
+ * progress. This structure will be deallocated when the copy is
* completed.
*/
@@ -7983,9 +7932,9 @@ TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
*/
static int
-CopyData(csPtr, mask)
- CopyState *csPtr; /* State of copy operation. */
- int mask; /* Current channel event flags. */
+CopyData(
+ CopyState *csPtr, /* State of copy operation. */
+ int mask) /* Current channel event flags. */
{
Tcl_Interp *interp;
Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL;
@@ -8027,13 +7976,13 @@ CopyData(csPtr, mask)
* Check for unreported background errors.
*/
- Tcl_GetChannelError (inChan, &msg);
+ Tcl_GetChannelError (inChan, &msg);
if ((inStatePtr->unreportedError != 0) || (msg != NULL)) {
Tcl_SetErrno(inStatePtr->unreportedError);
inStatePtr->unreportedError = 0;
goto readError;
}
- Tcl_GetChannelError (outChan, &msg);
+ Tcl_GetChannelError (outChan, &msg);
if ((outStatePtr->unreportedError != 0) || (msg != NULL)) {
Tcl_SetErrno(outStatePtr->unreportedError);
outStatePtr->unreportedError = 0;
@@ -8061,19 +8010,16 @@ CopyData(csPtr, mask)
readError:
TclNewObj(errObj);
Tcl_AppendStringsToObj(errObj, "error reading \"",
- Tcl_GetChannelName(inChan), "\": ",
- (char *) NULL);
+ Tcl_GetChannelName(inChan), "\": ", NULL);
if (msg != NULL) {
- Tcl_AppendObjToObj(errObj,msg);
+ Tcl_AppendObjToObj(errObj,msg);
} else {
- Tcl_AppendStringsToObj(errObj,
- Tcl_PosixError(interp),
- (char *) NULL);
+ Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), NULL);
}
break;
} else if (underflow) {
/*
- * We had an underflow on the read side. If we are at EOF, then
+ * We had an underflow on the read side. If we are at EOF, then
* the copying is done, otherwise set up a channel handler to
* detect when the channel becomes readable again.
*/
@@ -8086,13 +8032,13 @@ CopyData(csPtr, mask)
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
(ClientData) csPtr);
}
- Tcl_CreateChannelHandler(inChan, TCL_READABLE,
- CopyEventProc, (ClientData) csPtr);
+ Tcl_CreateChannelHandler(inChan, TCL_READABLE, CopyEventProc,
+ (ClientData) csPtr);
}
if (size == 0) {
- if (bufObj != (Tcl_Obj *) NULL) {
+ if (bufObj != NULL) {
TclDecrRefCount(bufObj);
- bufObj = (Tcl_Obj *) NULL;
+ bufObj = NULL;
}
return TCL_OK;
}
@@ -8124,14 +8070,11 @@ CopyData(csPtr, mask)
writeError:
TclNewObj(errObj);
Tcl_AppendStringsToObj(errObj, "error writing \"",
- Tcl_GetChannelName(outChan), "\": ",
- (char *) NULL);
+ Tcl_GetChannelName(outChan), "\": ", NULL);
if (msg != NULL) {
- Tcl_AppendObjToObj(errObj,msg);
+ Tcl_AppendObjToObj(errObj,msg);
} else {
- Tcl_AppendStringsToObj(errObj,
- Tcl_PosixError(interp),
- (char *) NULL);
+ Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), NULL);
}
break;
}
@@ -8157,7 +8100,7 @@ CopyData(csPtr, mask)
}
/*
- * Check to see if the write is happening in the background. If so,
+ * Check to see if the write is happening in the background. If so,
* stop copying and wait for the channel to become writable again.
* After input underflow we already installed a readable handler
* therefore we don't need a writable handler.
@@ -8172,9 +8115,9 @@ CopyData(csPtr, mask)
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
CopyEventProc, (ClientData) csPtr);
}
- if (bufObj != (Tcl_Obj *) NULL) {
+ if (bufObj != NULL) {
TclDecrRefCount(bufObj);
- bufObj = (Tcl_Obj *) NULL;
+ bufObj = NULL;
}
return TCL_OK;
}
@@ -8191,20 +8134,20 @@ CopyData(csPtr, mask)
*/
if (mask == 0) {
- Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
- CopyEventProc, (ClientData) csPtr);
+ Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc,
+ (ClientData) csPtr);
}
- if (bufObj != (Tcl_Obj *) NULL) {
+ if (bufObj != NULL) {
TclDecrRefCount(bufObj);
- bufObj = (Tcl_Obj *) NULL;
+ bufObj = NULL;
}
return TCL_OK;
}
} /* while */
- if (bufObj != (Tcl_Obj *) NULL) {
+ if (bufObj != NULL) {
TclDecrRefCount(bufObj);
- bufObj = (Tcl_Obj *) NULL;
+ bufObj = NULL;
}
/*
@@ -8216,7 +8159,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 reference to the
+ * arguments. Note that StopCopy frees our saved reference to the
* original command obj.
*/
@@ -8268,10 +8211,10 @@ CopyData(csPtr, mask)
*/
static int
-DoRead(chanPtr, bufPtr, toRead)
- Channel *chanPtr; /* The channel from which to read. */
- char *bufPtr; /* Where to store input read. */
- int toRead; /* Maximum number of bytes to read. */
+DoRead(
+ Channel *chanPtr, /* The channel from which to read. */
+ char *bufPtr, /* Where to store input read. */
+ int toRead) /* Maximum number of bytes to read. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
int copied; /* How many characters were copied into the
@@ -8346,10 +8289,10 @@ DoRead(chanPtr, bufPtr, toRead)
*/
static int
-CopyAndTranslateBuffer(statePtr, result, space)
- ChannelState *statePtr; /* Channel state from which to read input. */
- char *result; /* Where to store the copied input. */
- int space; /* How many bytes are available in result to
+CopyAndTranslateBuffer(
+ ChannelState *statePtr, /* Channel state from which to read input. */
+ char *result, /* Where to store the copied input. */
+ int space) /* How many bytes are available in result to
* store the copied input? */
{
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
@@ -8367,7 +8310,7 @@ CopyAndTranslateBuffer(statePtr, result, space)
* also that if the buffer is empty, we leave it in the queue.
*/
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
+ if (statePtr->inQueueHead == NULL) {
return 0;
}
bufPtr = statePtr->inQueueHead;
@@ -8542,8 +8485,8 @@ CopyAndTranslateBuffer(statePtr, result, space)
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
statePtr->inQueueHead = bufPtr->nextPtr;
- if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
- statePtr->inQueueTail = (ChannelBuffer *) NULL;
+ if (statePtr->inQueueHead == NULL) {
+ statePtr->inQueueTail = NULL;
}
RecycleBuffer(statePtr, bufPtr, 0);
}
@@ -8575,10 +8518,10 @@ CopyAndTranslateBuffer(statePtr, result, space)
*/
static int
-CopyBuffer(chanPtr, result, space)
- Channel *chanPtr; /* Channel from which to read input. */
- char *result; /* Where to store the copied input. */
- int space; /* How many bytes are available in result to
+CopyBuffer(
+ Channel *chanPtr, /* Channel from which to read input. */
+ char *result, /* Where to store the copied input. */
+ int space) /* How many bytes are available in result to
* store the copied input? */
{
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
@@ -8595,7 +8538,7 @@ CopyBuffer(chanPtr, result, space)
* recycle it.
*/
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
+ if (chanPtr->inQueueHead == NULL) {
return 0;
}
bufPtr = chanPtr->inQueueHead;
@@ -8605,8 +8548,8 @@ CopyBuffer(chanPtr, result, space)
if (bytesInBuffer == 0) {
RecycleBuffer(chanPtr->state, bufPtr, 0);
- chanPtr->inQueueHead = (ChannelBuffer *) NULL;
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ chanPtr->inQueueHead = NULL;
+ chanPtr->inQueueTail = NULL;
return 0;
}
@@ -8635,8 +8578,8 @@ CopyBuffer(chanPtr, result, space)
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
chanPtr->inQueueHead = bufPtr->nextPtr;
- if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
- chanPtr->inQueueTail = (ChannelBuffer *) NULL;
+ if (chanPtr->inQueueHead == NULL) {
+ chanPtr->inQueueTail = NULL;
}
RecycleBuffer(chanPtr->state, bufPtr, 0);
}
@@ -8670,29 +8613,27 @@ CopyBuffer(chanPtr, result, space)
*/
static int
-DoWrite(chanPtr, src, srcLen)
- Channel *chanPtr; /* The channel to buffer output for. */
- CONST char *src; /* Data to write. */
- int srcLen; /* Number of bytes to write. */
+DoWrite(
+ Channel *chanPtr, /* The channel to buffer output for. */
+ CONST char *src, /* Data to write. */
+ int srcLen) /* Number of bytes to write. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
- ChannelBuffer *outBufPtr; /* Current output buffer. */
- int foundNewline; /* Did we find a newline in output? */
+ ChannelBuffer *outBufPtr; /* Current output buffer. */
+ int foundNewline; /* Did we find a newline in output? */
char *dPtr;
- CONST char *sPtr; /* Search variables for newline. */
- int crsent; /* In CRLF eol translation mode,
- * remember the fact that a CR was
- * output to the channel without its
- * following NL. */
- int i; /* Loop index for newline search. */
- int destCopied; /* How many bytes were used in this
- * destination buffer to hold the
- * output? */
- int totalDestCopied; /* How many bytes total were copied to
- * the channel buffer? */
- int srcCopied; /* How many bytes were copied from the
- * source string? */
- char *destPtr; /* Where in line to copy to? */
+ CONST char *sPtr; /* Search variables for newline. */
+ int crsent; /* In CRLF eol translation mode, remember the
+ * fact that a CR was output to the channel
+ * without its following NL. */
+ int i; /* Loop index for newline search. */
+ int destCopied; /* How many bytes were used in this
+ * destination buffer to hold the output? */
+ int totalDestCopied; /* How many bytes total were copied to the
+ * channel buffer? */
+ int srcCopied; /* How many bytes were copied from the source
+ * string? */
+ char *destPtr; /* Where in line to copy to? */
/*
* If we are in network (or windows) translation mode, record the fact
@@ -8710,12 +8651,11 @@ DoWrite(chanPtr, src, srcLen)
totalDestCopied = 0;
while (srcLen > 0) {
-
/*
* Make sure there is a current output buffer to accept output.
*/
- if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
+ if (statePtr->curOutPtr == NULL) {
statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
}
@@ -8825,9 +8765,9 @@ DoWrite(chanPtr, src, srcLen)
*/
static void
-CopyEventProc(clientData, mask)
- ClientData clientData;
- int mask;
+CopyEventProc(
+ ClientData clientData,
+ int mask)
{
(void) CopyData((CopyState *) clientData, mask);
}
@@ -8850,8 +8790,8 @@ CopyEventProc(clientData, mask)
*/
static void
-StopCopy(csPtr)
- CopyState *csPtr; /* State for bg copy to stop . */
+StopCopy(
+ CopyState *csPtr) /* State for bg copy to stop . */
{
ChannelState *inStatePtr, *outStatePtr;
int nonBlocking;
@@ -8916,9 +8856,9 @@ StopCopy(csPtr)
*/
static int
-StackSetBlockMode(chanPtr, mode)
- Channel *chanPtr; /* Channel to modify. */
- int mode; /* One of TCL_MODE_BLOCKING or
+StackSetBlockMode(
+ Channel *chanPtr, /* Channel to modify. */
+ int mode) /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
int result = 0;
@@ -8929,7 +8869,7 @@ StackSetBlockMode(chanPtr, mode)
*/
chanPtr = chanPtr->state->topChanPtr;
- while (chanPtr != (Channel *) NULL) {
+ while (chanPtr != NULL) {
blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
if (blockModeProc != NULL) {
result = (*blockModeProc) (chanPtr->instanceData, mode);
@@ -8962,10 +8902,10 @@ StackSetBlockMode(chanPtr, mode)
*/
static int
-SetBlockMode(interp, chanPtr, mode)
- Tcl_Interp *interp; /* Interp for error reporting. */
- Channel *chanPtr; /* Channel to modify. */
- int mode; /* One of TCL_MODE_BLOCKING or
+SetBlockMode(
+ Tcl_Interp *interp, /* Interp for error reporting. */
+ Channel *chanPtr, /* Channel to modify. */
+ int mode) /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
ChannelState *statePtr = chanPtr->state; /* state info for channel */
@@ -8973,8 +8913,9 @@ SetBlockMode(interp, chanPtr, mode)
result = StackSetBlockMode(chanPtr, mode);
if (result != 0) {
- if (interp != (Tcl_Interp *) NULL) {
- /* TIP #219.
+ if (interp != NULL) {
+ /*
+ * TIP #219.
* Move error messages put by the driver into the bypass area and
* put them into the regular interpreter result. Fall back to the
* regular message if nothing was found in the bypass.
@@ -8983,17 +8924,20 @@ SetBlockMode(interp, chanPtr, mode)
* area, StackSetBlockMode is restricted to the channel bypass.
* We still need the interp as the destination of the move.
*/
+
if (!TclChanCaughtErrorBypass (interp, (Tcl_Channel) chanPtr)) {
Tcl_AppendResult(interp, "error setting blocking mode: ",
- Tcl_PosixError(interp), (char *) NULL);
+ Tcl_PosixError(interp), NULL);
}
} else {
- /* TIP #219.
+ /*
+ * TIP #219.
* If we have no interpreter to put a bypass message into we have
* to clear it, to prevent its propagation and use in other places
* unrelated to the actual occurence of the problem.
*/
- Tcl_SetChannelError ((Tcl_Channel) chanPtr, NULL);
+
+ Tcl_SetChannelError((Tcl_Channel) chanPtr, NULL);
}
return TCL_ERROR;
}
@@ -9022,10 +8966,10 @@ SetBlockMode(interp, chanPtr, mode)
*/
int
-Tcl_GetChannelNames(interp)
- Tcl_Interp *interp; /* Interp for error reporting. */
+Tcl_GetChannelNames(
+ Tcl_Interp *interp) /* Interp for error reporting. */
{
- return Tcl_GetChannelNamesEx(interp, (char *) NULL);
+ return Tcl_GetChannelNamesEx(interp, NULL);
}
/*
@@ -9034,7 +8978,7 @@ Tcl_GetChannelNames(interp)
* Tcl_GetChannelNamesEx --
*
* Return the names of open channels in the interp filtered filtered
- * through a pattern. If pattern is NULL, it returns all the open
+ * through a pattern. If pattern is NULL, it returns all the open
* channels.
*
* Results:
@@ -9047,9 +8991,9 @@ Tcl_GetChannelNames(interp)
*/
int
-Tcl_GetChannelNamesEx(interp, pattern)
- Tcl_Interp *interp; /* Interp for error reporting. */
- CONST char *pattern; /* pattern to filter on. */
+Tcl_GetChannelNamesEx(
+ Tcl_Interp *interp, /* Interp for error reporting. */
+ CONST char *pattern) /* Pattern to filter on. */
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelState *statePtr;
@@ -9059,7 +9003,7 @@ Tcl_GetChannelNamesEx(interp, pattern)
Tcl_HashEntry *hPtr; /* Search variable. */
Tcl_HashSearch hSearch; /* Search variable. */
- if (interp == (Tcl_Interp *) NULL) {
+ if (interp == NULL) {
return TCL_OK;
}
@@ -9080,8 +9024,7 @@ Tcl_GetChannelNamesEx(interp, pattern)
}
goto done;
}
- for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
- hPtr != (Tcl_HashEntry *) NULL;
+ for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
hPtr = Tcl_NextHashEntry(&hSearch)) {
statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state;
@@ -9119,7 +9062,7 @@ Tcl_GetChannelNamesEx(interp, pattern)
*
* Tcl_IsChannelRegistered --
*
- * Checks whether the channel is associated with the interp. See also
+ * Checks whether the channel is associated with the interp. See also
* Tcl_RegisterChannel and Tcl_UnregisterChannel.
*
* Results:
@@ -9132,17 +9075,17 @@ Tcl_GetChannelNamesEx(interp, pattern)
*/
int
-Tcl_IsChannelRegistered(interp, chan)
- Tcl_Interp *interp; /* The interp to query of the channel */
- Tcl_Channel chan; /* The channel to check */
+Tcl_IsChannelRegistered(
+ Tcl_Interp *interp, /* The interp to query of the channel */
+ Tcl_Channel chan) /* The channel to check */
{
- Tcl_HashTable *hTblPtr; /* Hash table of channels. */
- Tcl_HashEntry *hPtr; /* Search variable. */
- Channel *chanPtr; /* The real IO channel. */
- ChannelState *statePtr; /* State of the real channel. */
+ Tcl_HashTable *hTblPtr; /* Hash table of channels. */
+ Tcl_HashEntry *hPtr; /* Search variable. */
+ Channel *chanPtr; /* The real IO channel. */
+ ChannelState *statePtr; /* State of the real channel. */
/*
- * Always check bottom-most channel in the stack. This is the one that
+ * Always check bottom-most channel in the stack. This is the one that
* gets registered.
*/
@@ -9150,11 +9093,11 @@ Tcl_IsChannelRegistered(interp, chan)
statePtr = chanPtr->state;
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
- if (hTblPtr == (Tcl_HashTable *) NULL) {
+ if (hTblPtr == NULL) {
return 0;
}
hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
- if (hPtr == (Tcl_HashEntry *) NULL) {
+ if (hPtr == NULL) {
return 0;
}
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
@@ -9181,11 +9124,11 @@ Tcl_IsChannelRegistered(interp, chan)
*/
int
-Tcl_IsChannelShared(chan)
- Tcl_Channel chan; /* The channel to query */
+Tcl_IsChannelShared(
+ Tcl_Channel chan) /* The channel to query */
{
ChannelState *statePtr = ((Channel *) chan)->state;
- /* State of real channel structure. */
+ /* State of real channel structure. */
return ((statePtr->refCount > 1) ? 1 : 0);
}
@@ -9196,7 +9139,7 @@ Tcl_IsChannelShared(chan)
* Tcl_IsChannelExisting --
*
* Checks whether a channel of the given name exists in the
- * (thread)-global list of all channels. See Tcl_GetChannelNamesEx for
+ * (thread)-global list of all channels. See Tcl_GetChannelNamesEx for
* function exposed at the Tcl level.
*
* Results:
@@ -9209,8 +9152,8 @@ Tcl_IsChannelShared(chan)
*/
int
-Tcl_IsChannelExisting(chanName)
- CONST char *chanName; /* The name of the channel to look for. */
+Tcl_IsChannelExisting(
+ CONST char *chanName) /* The name of the channel to look for. */
{
ChannelState *statePtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -9218,8 +9161,7 @@ Tcl_IsChannelExisting(chanName)
int chanNameLen;
chanNameLen = strlen(chanName);
- for (statePtr = tsdPtr->firstCSPtr;
- statePtr != NULL;
+ for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL;
statePtr = statePtr->nextCSPtr) {
if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
name = "stdin";
@@ -9257,8 +9199,8 @@ Tcl_IsChannelExisting(chanName)
*/
CONST char *
-Tcl_ChannelName(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelName(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->typeName;
}
@@ -9280,8 +9222,8 @@ Tcl_ChannelName(chanTypePtr)
*/
Tcl_ChannelTypeVersion
-Tcl_ChannelVersion(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelVersion(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
return TCL_CHANNEL_VERSION_2;
@@ -9317,9 +9259,9 @@ Tcl_ChannelVersion(chanTypePtr)
*/
static int
-HaveVersion(chanTypePtr, minimumVersion)
- Tcl_ChannelType *chanTypePtr;
- Tcl_ChannelTypeVersion minimumVersion;
+HaveVersion(
+ Tcl_ChannelType *chanTypePtr,
+ Tcl_ChannelTypeVersion minimumVersion)
{
Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr);
@@ -9342,8 +9284,8 @@ HaveVersion(chanTypePtr, minimumVersion)
*---------------------------------------------------------------------- */
Tcl_DriverBlockModeProc *
-Tcl_ChannelBlockModeProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelBlockModeProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->blockModeProc;
@@ -9373,8 +9315,8 @@ Tcl_ChannelBlockModeProc(chanTypePtr)
*/
Tcl_DriverCloseProc *
-Tcl_ChannelCloseProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelCloseProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->closeProc;
}
@@ -9396,8 +9338,8 @@ Tcl_ChannelCloseProc(chanTypePtr)
*/
Tcl_DriverClose2Proc *
-Tcl_ChannelClose2Proc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelClose2Proc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->close2Proc;
}
@@ -9419,8 +9361,8 @@ Tcl_ChannelClose2Proc(chanTypePtr)
*/
Tcl_DriverInputProc *
-Tcl_ChannelInputProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelInputProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->inputProc;
}
@@ -9442,8 +9384,8 @@ Tcl_ChannelInputProc(chanTypePtr)
*/
Tcl_DriverOutputProc *
-Tcl_ChannelOutputProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelOutputProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->outputProc;
}
@@ -9465,8 +9407,8 @@ Tcl_ChannelOutputProc(chanTypePtr)
*/
Tcl_DriverSeekProc *
-Tcl_ChannelSeekProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelSeekProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->seekProc;
}
@@ -9488,8 +9430,8 @@ Tcl_ChannelSeekProc(chanTypePtr)
*/
Tcl_DriverSetOptionProc *
-Tcl_ChannelSetOptionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelSetOptionProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->setOptionProc;
}
@@ -9511,8 +9453,8 @@ Tcl_ChannelSetOptionProc(chanTypePtr)
*/
Tcl_DriverGetOptionProc *
-Tcl_ChannelGetOptionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelGetOptionProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->getOptionProc;
}
@@ -9534,8 +9476,8 @@ Tcl_ChannelGetOptionProc(chanTypePtr)
*/
Tcl_DriverWatchProc *
-Tcl_ChannelWatchProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelWatchProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->watchProc;
}
@@ -9557,8 +9499,8 @@ Tcl_ChannelWatchProc(chanTypePtr)
*/
Tcl_DriverGetHandleProc *
-Tcl_ChannelGetHandleProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelGetHandleProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
return chanTypePtr->getHandleProc;
}
@@ -9580,8 +9522,8 @@ Tcl_ChannelGetHandleProc(chanTypePtr)
*/
Tcl_DriverFlushProc *
-Tcl_ChannelFlushProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelFlushProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->flushProc;
@@ -9607,8 +9549,8 @@ Tcl_ChannelFlushProc(chanTypePtr)
*/
Tcl_DriverHandlerProc *
-Tcl_ChannelHandlerProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelHandlerProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->handlerProc;
@@ -9634,8 +9576,8 @@ Tcl_ChannelHandlerProc(chanTypePtr)
*/
Tcl_DriverWideSeekProc *
-Tcl_ChannelWideSeekProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelWideSeekProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) {
return chanTypePtr->wideSeekProc;
@@ -9649,7 +9591,7 @@ Tcl_ChannelWideSeekProc(chanTypePtr)
*
* Tcl_ChannelThreadActionProc --
*
- * TIP #218, Channel Thread Actions. Return the
+ * TIP #218, Channel Thread Actions. Return the
* Tcl_DriverThreadActionProc of the channel type.
*
* Results:
@@ -9662,8 +9604,8 @@ Tcl_ChannelWideSeekProc(chanTypePtr)
*/
Tcl_DriverThreadActionProc *
-Tcl_ChannelThreadActionProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelThreadActionProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
return chanTypePtr->threadActionProc;
@@ -9677,7 +9619,7 @@ Tcl_ChannelThreadActionProc(chanTypePtr)
*
* Tcl_SetChannelErrorInterp --
*
- * TIP #219, Tcl Channel Reflection API.
+ * TIP #219, Tcl Channel Reflection API.
* Store an error message for the I/O system.
*
* Results:
@@ -9690,20 +9632,20 @@ Tcl_ChannelThreadActionProc(chanTypePtr)
*/
void
-Tcl_SetChannelErrorInterp (interp, msg)
- Tcl_Interp* interp; /* Interp to store the data into. */
- Tcl_Obj* msg; /* Error message to store. */
+Tcl_SetChannelErrorInterp(
+ Tcl_Interp *interp, /* Interp to store the data into. */
+ Tcl_Obj *msg) /* Error message to store. */
{
- Interp* iPtr = (Interp*) interp;
+ Interp *iPtr = (Interp *) interp;
if (iPtr->chanMsg != NULL) {
- Tcl_DecrRefCount (iPtr->chanMsg);
- iPtr->chanMsg = NULL;
+ Tcl_DecrRefCount(iPtr->chanMsg);
+ iPtr->chanMsg = NULL;
}
if (msg != NULL) {
- iPtr->chanMsg = FixLevelCode (msg);
- Tcl_IncrRefCount (iPtr->chanMsg);
+ iPtr->chanMsg = FixLevelCode(msg);
+ Tcl_IncrRefCount(iPtr->chanMsg);
}
return;
}
@@ -9713,7 +9655,7 @@ Tcl_SetChannelErrorInterp (interp, msg)
*
* Tcl_SetChannelError --
*
- * TIP #219, Tcl Channel Reflection API.
+ * TIP #219, Tcl Channel Reflection API.
* Store an error message for the I/O system.
*
* Results:
@@ -9726,20 +9668,20 @@ Tcl_SetChannelErrorInterp (interp, msg)
*/
void
-Tcl_SetChannelError (chan, msg)
- Tcl_Channel chan; /* Channel to store the data into. */
- Tcl_Obj* msg; /* Error message to store. */
+Tcl_SetChannelError(
+ Tcl_Channel chan, /* Channel to store the data into. */
+ Tcl_Obj *msg) /* Error message to store. */
{
ChannelState* statePtr = ((Channel*) chan)->state;
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount (statePtr->chanMsg);
- statePtr->chanMsg = NULL;
+ Tcl_DecrRefCount(statePtr->chanMsg);
+ statePtr->chanMsg = NULL;
}
if (msg != NULL) {
- statePtr->chanMsg = FixLevelCode (msg);
- Tcl_IncrRefCount (statePtr->chanMsg);
+ statePtr->chanMsg = FixLevelCode(msg);
+ Tcl_IncrRefCount(statePtr->chanMsg);
}
return;
}
@@ -9749,10 +9691,9 @@ Tcl_SetChannelError (chan, msg)
*
* FixLevelCode --
*
- * TIP #219, Tcl Channel Reflection API.
- * Scans an error message for bad -code / -level
- * directives. Returns a modified copy with such
- * directives corrected, and the input if it had
+ * TIP #219, Tcl Channel Reflection API.
+ * Scans an error message for bad -code / -level directives. Returns a
+ * modified copy with such directives corrected, and the input if it had
* no problems.
*
* Results:
@@ -9764,23 +9705,24 @@ Tcl_SetChannelError (chan, msg)
*----------------------------------------------------------------------
*/
-static Tcl_Obj*
-FixLevelCode (msg)
-Tcl_Obj* msg;
+static Tcl_Obj *
+FixLevelCode(
+ Tcl_Obj *msg)
{
- int lc;
- Tcl_Obj** lv;
- int explicitResult;
- int numOptions;
- int lcn;
- Tcl_Obj** lvn;
- int res, i, j, val, lignore, cignore;
- Tcl_Obj* newlevel = NULL;
- Tcl_Obj* newcode = NULL;
+ int lc;
+ Tcl_Obj **lv;
+ int explicitResult;
+ int numOptions;
+ int lcn;
+ Tcl_Obj **lvn;
+ int res, i, j, val, lignore, cignore;
+ Tcl_Obj *newlevel = NULL;
+ Tcl_Obj *newcode = NULL;
/* ASSERT msg != NULL */
- /* Process the caught message.
+ /*
+ * Process the caught message.
*
* Syntax = (option value)... ?message?
*
@@ -9789,42 +9731,51 @@ Tcl_Obj* msg;
* information.
*/
- res = Tcl_ListObjGetElements (NULL, msg, &lc, &lv);
+ res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv);
if (res != TCL_OK) {
- Tcl_Panic ("Tcl_SetChannelError(Interp): Bad syntax of message");
+ Tcl_Panic("Tcl_SetChannelError(Interp): Bad syntax of message");
}
explicitResult = (1 == (lc % 2));
- numOptions = lc - explicitResult;
+ numOptions = lc - explicitResult;
- /* No options, nothing to do.
+ /*
+ * No options, nothing to do.
*/
if (numOptions == 0) {
return msg;
}
- /* Check for -code x, x != 1|error, and -level x, x != 0 */
+ /*
+ * Check for -code x, x != 1|error, and -level x, x != 0
+ */
for (i = 0; i < numOptions; i += 2) {
- if (0 == strcmp (Tcl_GetString (lv [i]), "-code")) {
- /* !"error", !integer, integer != 1 (numeric code for error) */
+ if (0 == strcmp(TclGetString(lv[i]), "-code")) {
+ /*
+ * !"error", !integer, integer != 1 (numeric code for error)
+ */
- res = Tcl_GetIntFromObj (NULL, lv [i+1], &val);
- if (((res == TCL_OK) && (val != 1)) ||
- ((res != TCL_OK) && (0 != strcmp (Tcl_GetString (lv [i+1]), "error")))) {
- newcode = Tcl_NewIntObj (1);
+ res = Tcl_GetIntFromObj(NULL, lv[i+1], &val);
+ if (((res == TCL_OK) && (val != 1)) || ((res != TCL_OK) &&
+ (0 != strcmp(TclGetString(lv[i+1]), "error")))) {
+ newcode = Tcl_NewIntObj(1);
}
- } else if (0 == strcmp (Tcl_GetString (lv [i]), "-level")) {
- /* !integer, integer != 0 */
- res = Tcl_GetIntFromObj (NULL, lv [i+1], &val);
+ } else if (0 == strcmp(TclGetString(lv[i]), "-level")) {
+ /*
+ * !integer, integer != 0
+ */
+
+ res = Tcl_GetIntFromObj(NULL, lv [i+1], &val);
if ((res != TCL_OK) || (val != 0)) {
- newlevel = Tcl_NewIntObj (0);
+ newlevel = Tcl_NewIntObj(0);
}
}
}
- /* -code, -level are either not present or ok. Nothing to do.
+ /*
+ * -code, -level are either not present or ok. Nothing to do.
*/
if (!newlevel && !newcode) {
@@ -9832,34 +9783,41 @@ Tcl_Obj* msg;
}
lcn = numOptions;
- if (explicitResult) lcn ++;
- if (newlevel) lcn += 2;
- if (newcode) lcn += 2;
+ if (explicitResult) {
+ lcn ++;
+ }
+ if (newlevel) {
+ lcn += 2;
+ }
+ if (newcode) {
+ lcn += 2;
+ }
- lvn = (Tcl_Obj**) ckalloc (lcn * sizeof (Tcl_Obj*));
+ lvn = (Tcl_Obj **) ckalloc(lcn * sizeof(Tcl_Obj *));
- /* New level/code information is spliced into the first occurence of
+ /*
+ * New level/code information is spliced into the first occurence of
* -level, -code, further occurences are ignored. The options cannot be
* not present, we would not come here. Options which are ok are simply
* copied over.
*/
lignore = cignore = 0;
- for (i = 0, j = 0; i < numOptions; i += 2) {
- if (0 == strcmp (Tcl_GetString (lv [i]), "-level")) {
+ for (i=0, j=0; i<numOptions; i+=2) {
+ if (0 == strcmp(TclGetString(lv[i]), "-level")) {
if (newlevel) {
- lvn [j] = lv [i]; j++;
- lvn [j] = newlevel; j++;
+ lvn[j++] = lv[i];
+ lvn[j++] = newlevel;
newlevel = NULL;
lignore = 1;
continue;
} else if (lignore) {
continue;
}
- } else if (0 == strcmp (Tcl_GetString (lv [i]), "-code")) {
+ } else if (0 == strcmp(TclGetString(lv[i]), "-code")) {
if (newcode) {
- lvn [j] = lv [i]; j++;
- lvn [j] = newcode; j++;
+ lvn[j++] = lv[i];
+ lvn[j++] = newcode;
newcode = NULL;
cignore = 1;
continue;
@@ -9867,18 +9825,22 @@ Tcl_Obj* msg;
continue;
}
}
- /* Keep everything else, possibly copied down */
- lvn [j] = lv [i]; j++;
- lvn [j] = lv [i+1]; j++;
+
+ /*
+ * Keep everything else, possibly copied down.
+ */
+
+ lvn[j++] = lv[i];
+ lvn[j++] = lv[i+1];
}
if (explicitResult) {
- lvn [j] = lv [i]; j++;
+ lvn[j++] = lv[i];
}
- msg = Tcl_NewListObj (j, lvn);
+ msg = Tcl_NewListObj(j, lvn);
- ckfree ((char*) lvn);
+ ckfree((char *) lvn);
return msg;
}
@@ -9887,7 +9849,7 @@ Tcl_Obj* msg;
*
* Tcl_GetChannelErrorInterp --
*
- * TIP #219, Tcl Channel Reflection API.
+ * TIP #219, Tcl Channel Reflection API.
* Return the message stored by the channel driver.
*
* Results:
@@ -9899,14 +9861,15 @@ Tcl_Obj* msg;
*----------------------------------------------------------------------
*/
-void Tcl_GetChannelErrorInterp (interp, msg)
- Tcl_Interp* interp; /* Interp to query. */
- Tcl_Obj** msg; /* Place for error message. */
+void
+Tcl_GetChannelErrorInterp(
+ Tcl_Interp *interp, /* Interp to query. */
+ Tcl_Obj **msg) /* Place for error message. */
{
- Interp* iPtr = (Interp*) interp;
+ Interp *iPtr = (Interp *) interp;
*msg = iPtr->chanMsg;
- iPtr->chanMsg = NULL;
+ iPtr->chanMsg = NULL;
}
/*
@@ -9914,7 +9877,7 @@ void Tcl_GetChannelErrorInterp (interp, msg)
*
* Tcl_GetChannelError --
*
- * TIP #219, Tcl Channel Reflection API.
+ * TIP #219, Tcl Channel Reflection API.
* Return the message stored by the channel driver.
*
* Results:
@@ -9926,14 +9889,15 @@ void Tcl_GetChannelErrorInterp (interp, msg)
*----------------------------------------------------------------------
*/
-void Tcl_GetChannelError (chan, msg)
- Tcl_Channel chan; /* Channel to query. */
- Tcl_Obj** msg; /* Place for error message. */
+void
+Tcl_GetChannelError(
+ Tcl_Channel chan, /* Channel to query. */
+ Tcl_Obj **msg) /* Place for error message. */
{
- ChannelState* statePtr = ((Channel*) chan)->state;
+ ChannelState *statePtr = ((Channel *) chan)->state;
*msg = statePtr->chanMsg;
- statePtr->chanMsg = NULL;
+ statePtr->chanMsg = NULL;
}
/*
@@ -9954,8 +9918,8 @@ void Tcl_GetChannelError (chan, msg)
*/
Tcl_DriverTruncateProc *
-Tcl_ChannelTruncateProc(chanTypePtr)
- Tcl_ChannelType *chanTypePtr; /* Pointer to channel type. */
+Tcl_ChannelTruncateProc(
+ Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
return chanTypePtr->truncateProc;
@@ -9971,9 +9935,9 @@ Tcl_ChannelTruncateProc(chanTypePtr)
*/
static int
-DumpFlags(str, flags)
- char *str;
- int flags;
+DumpFlags(
+ char *str,
+ int flags)
{
char buf[20];
int i = 0;