diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/tclHash.c | 179 | ||||
| -rw-r--r-- | generic/tclIO.c | 2288 | ||||
| -rw-r--r-- | generic/tclLoad.c | 181 | ||||
| -rw-r--r-- | generic/tclParseExpr.c | 146 | ||||
| -rw-r--r-- | generic/tclTimer.c | 139 | ||||
| -rw-r--r-- | generic/tclUtf.c | 330 |
6 files changed, 1611 insertions, 1652 deletions
diff --git a/generic/tclHash.c b/generic/tclHash.c index 861eb47..04159d8 100644 --- a/generic/tclHash.c +++ b/generic/tclHash.c @@ -1,4 +1,4 @@ -/* +/* * tclHash.c -- * * Implementation of in-memory hash tables for Tcl and Tcl-based @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclHash.c,v 1.23 2005/07/21 14:38:32 dkf Exp $ + * RCS: @(#) $Id: tclHash.c,v 1.24 2005/10/31 15:59:41 dkf Exp $ */ #include "tclInt.h" @@ -45,49 +45,41 @@ * Prototypes for the array hash key methods. */ -static Tcl_HashEntry * AllocArrayEntry _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); -static int CompareArrayKeys _ANSI_ARGS_(( - VOID *keyPtr, Tcl_HashEntry *hPtr)); -static unsigned int HashArrayKey _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); +static Tcl_HashEntry * AllocArrayEntry(Tcl_HashTable *tablePtr, VOID *keyPtr); +static int CompareArrayKeys(VOID *keyPtr, Tcl_HashEntry *hPtr); +static unsigned int HashArrayKey(Tcl_HashTable *tablePtr, VOID *keyPtr); /* * Prototypes for the one word hash key methods. */ #if 0 -static Tcl_HashEntry * AllocOneWordEntry _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); -static int CompareOneWordKeys _ANSI_ARGS_(( - VOID *keyPtr, Tcl_HashEntry *hPtr)); -static unsigned int HashOneWordKey _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); +static Tcl_HashEntry * AllocOneWordEntry(Tcl_HashTable *tablePtr, + VOID *keyPtr); +static int CompareOneWordKeys(VOID *keyPtr, Tcl_HashEntry *hPtr); +static unsigned int HashOneWordKey(Tcl_HashTable *tablePtr, VOID *keyPtr); #endif /* * Prototypes for the string hash key methods. */ -static Tcl_HashEntry * AllocStringEntry _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); -static int CompareStringKeys _ANSI_ARGS_(( - VOID *keyPtr, Tcl_HashEntry *hPtr)); -static unsigned int HashStringKey _ANSI_ARGS_(( - Tcl_HashTable *tablePtr, VOID *keyPtr)); +static Tcl_HashEntry * AllocStringEntry(Tcl_HashTable *tablePtr, + VOID *keyPtr); +static int CompareStringKeys(VOID *keyPtr, Tcl_HashEntry *hPtr); +static unsigned int HashStringKey(Tcl_HashTable *tablePtr, VOID *keyPtr); /* * Function prototypes for static functions in this file: */ #if TCL_PRESERVE_BINARY_COMPATABILITY -static Tcl_HashEntry * BogusFind _ANSI_ARGS_((Tcl_HashTable *tablePtr, - CONST char *key)); -static Tcl_HashEntry * BogusCreate _ANSI_ARGS_((Tcl_HashTable *tablePtr, - CONST char *key, int *newPtr)); +static Tcl_HashEntry * BogusFind(Tcl_HashTable *tablePtr, CONST char *key); +static Tcl_HashEntry * BogusCreate(Tcl_HashTable *tablePtr, CONST char *key, + int *newPtr); #endif -static void RebuildTable _ANSI_ARGS_((Tcl_HashTable *tablePtr)); +static void RebuildTable(Tcl_HashTable *tablePtr); Tcl_HashKeyType tclArrayHashKeyType = { TCL_HASH_KEY_TYPE_VERSION, /* version */ @@ -136,12 +128,13 @@ Tcl_HashKeyType tclStringHashKeyType = { #undef Tcl_InitHashTable void -Tcl_InitHashTable(tablePtr, keyType) - register Tcl_HashTable *tablePtr; /* Pointer to table record, which is - * supplied by the caller. */ - int keyType; /* Type of keys to use in table: - * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, - * or an integer >= 2. */ +Tcl_InitHashTable( + register Tcl_HashTable *tablePtr, + /* Pointer to table record, which is supplied + * by the caller. */ + int keyType) /* Type of keys to use in table: + * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, or an + * integer >= 2. */ { /* * Use a special value to inform the extended version that it must not @@ -173,22 +166,22 @@ Tcl_InitHashTable(tablePtr, keyType) */ void -Tcl_InitCustomHashTable(tablePtr, keyType, typePtr) - register Tcl_HashTable *tablePtr; /* Pointer to table record, which is - * supplied by the caller. */ - int keyType; /* Type of keys to use in table: - * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, - * TCL_CUSTOM_TYPE_KEYS, - * TCL_CUSTOM_PTR_KEYS, or an integer - * >= 2. */ - Tcl_HashKeyType *typePtr; /* Pointer to structure which defines - * the behaviour of this table. */ +Tcl_InitCustomHashTable( + register Tcl_HashTable *tablePtr, + /* Pointer to table record, which is supplied + * by the caller. */ + int keyType, /* Type of keys to use in table: + * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, + * TCL_CUSTOM_TYPE_KEYS, TCL_CUSTOM_PTR_KEYS, + * or an integer >= 2. */ + Tcl_HashKeyType *typePtr) /* Pointer to structure which defines the + * behaviour of this table. */ { -#if (TCL_SMALL_HASH_TABLE != 4) +#if (TCL_SMALL_HASH_TABLE != 4) Tcl_Panic("Tcl_InitCustomHashTable: TCL_SMALL_HASH_TABLE is %d, not 4\n", TCL_SMALL_HASH_TABLE); #endif - + tablePtr->buckets = tablePtr->staticBuckets; tablePtr->staticBuckets[0] = tablePtr->staticBuckets[1] = 0; tablePtr->staticBuckets[2] = tablePtr->staticBuckets[3] = 0; @@ -266,9 +259,9 @@ Tcl_InitCustomHashTable(tablePtr, keyType, typePtr) */ Tcl_HashEntry * -Tcl_FindHashEntry(tablePtr, key) - Tcl_HashTable *tablePtr; /* Table in which to lookup entry. */ - CONST char *key; /* Key to use to find matching entry. */ +Tcl_FindHashEntry( + Tcl_HashTable *tablePtr, /* Table in which to lookup entry. */ + CONST char *key) /* Key to use to find matching entry. */ { register Tcl_HashEntry *hPtr; Tcl_HashKeyType *typePtr; @@ -336,7 +329,7 @@ Tcl_FindHashEntry(tablePtr, key) } } } - + return NULL; } @@ -362,11 +355,11 @@ Tcl_FindHashEntry(tablePtr, key) */ Tcl_HashEntry * -Tcl_CreateHashEntry(tablePtr, key, newPtr) - Tcl_HashTable *tablePtr; /* Table in which to lookup entry. */ - CONST char *key; /* Key to use to find or create matching +Tcl_CreateHashEntry( + Tcl_HashTable *tablePtr, /* Table in which to lookup entry. */ + CONST char *key, /* Key to use to find or create matching * entry. */ - int *newPtr; /* Store info here telling whether a new entry + int *newPtr) /* Store info here telling whether a new entry * was created. */ { register Tcl_HashEntry *hPtr; @@ -449,7 +442,7 @@ Tcl_CreateHashEntry(tablePtr, key, newPtr) hPtr = (Tcl_HashEntry *) ckalloc((unsigned) sizeof(Tcl_HashEntry)); hPtr->key.oneWordValue = (char *) key; } - + hPtr->tablePtr = tablePtr; #if TCL_HASH_KEY_STORE_HASH # if TCL_PRESERVE_BINARY_COMPATABILITY @@ -497,8 +490,8 @@ Tcl_CreateHashEntry(tablePtr, key, newPtr) */ void -Tcl_DeleteHashEntry(entryPtr) - Tcl_HashEntry *entryPtr; +Tcl_DeleteHashEntry( + Tcl_HashEntry *entryPtr) { register Tcl_HashEntry *prevPtr; Tcl_HashKeyType *typePtr; @@ -524,7 +517,7 @@ Tcl_DeleteHashEntry(entryPtr) #else typePtr = tablePtr->typePtr; #endif - + #if TCL_HASH_KEY_STORE_HASH if (typePtr->hashKeyProc == NULL || typePtr->flags & TCL_HASH_KEY_RANDOMIZE_HASH) { @@ -537,7 +530,7 @@ Tcl_DeleteHashEntry(entryPtr) #else bucketPtr = entryPtr->bucketPtr; #endif - + if (*bucketPtr == entryPtr) { *bucketPtr = entryPtr->nextPtr; } else { @@ -578,8 +571,8 @@ Tcl_DeleteHashEntry(entryPtr) */ void -Tcl_DeleteHashTable(tablePtr) - register Tcl_HashTable *tablePtr; /* Table to delete. */ +Tcl_DeleteHashTable( + register Tcl_HashTable *tablePtr) /* Table to delete. */ { register Tcl_HashEntry *hPtr, *nextPtr; Tcl_HashKeyType *typePtr; @@ -663,9 +656,9 @@ Tcl_DeleteHashTable(tablePtr) */ Tcl_HashEntry * -Tcl_FirstHashEntry(tablePtr, searchPtr) - Tcl_HashTable *tablePtr; /* Table to search. */ - Tcl_HashSearch *searchPtr; /* Place to store information about progress +Tcl_FirstHashEntry( + Tcl_HashTable *tablePtr, /* Table to search. */ + Tcl_HashSearch *searchPtr) /* Place to store information about progress * through the table. */ { searchPtr->tablePtr = tablePtr; @@ -694,8 +687,8 @@ Tcl_FirstHashEntry(tablePtr, searchPtr) */ Tcl_HashEntry * -Tcl_NextHashEntry(searchPtr) - register Tcl_HashSearch *searchPtr; +Tcl_NextHashEntry( + register Tcl_HashSearch *searchPtr) /* Place to store information about progress * through the table. Must have been * initialized by calling @@ -736,8 +729,8 @@ Tcl_NextHashEntry(searchPtr) */ CONST char * -Tcl_HashStats(tablePtr) - Tcl_HashTable *tablePtr; /* Table for which to produce stats. */ +Tcl_HashStats( + Tcl_HashTable *tablePtr) /* Table for which to produce stats. */ { #define NUM_COUNTERS 10 int count[NUM_COUNTERS], overflow, i, j; @@ -831,9 +824,9 @@ Tcl_HashStats(tablePtr) */ static Tcl_HashEntry * -AllocArrayEntry(tablePtr, keyPtr) - Tcl_HashTable *tablePtr; /* Hash table. */ - VOID *keyPtr; /* Key to store in the hash table entry. */ +AllocArrayEntry( + Tcl_HashTable *tablePtr, /* Hash table. */ + VOID *keyPtr) /* Key to store in the hash table entry. */ { int *array = (int *) keyPtr; register int *iPtr1, *iPtr2; @@ -848,7 +841,7 @@ AllocArrayEntry(tablePtr, keyPtr) size = sizeof(Tcl_HashEntry); } hPtr = (Tcl_HashEntry *) ckalloc(size); - + for (iPtr1 = array, iPtr2 = hPtr->key.words; count > 0; count--, iPtr1++, iPtr2++) { *iPtr2 = *iPtr1; @@ -875,9 +868,9 @@ AllocArrayEntry(tablePtr, keyPtr) */ static int -CompareArrayKeys(keyPtr, hPtr) - VOID *keyPtr; /* New key to compare. */ - Tcl_HashEntry *hPtr; /* Existing key to compare. */ +CompareArrayKeys( + VOID *keyPtr, /* New key to compare. */ + Tcl_HashEntry *hPtr) /* Existing key to compare. */ { register CONST int *iPtr1 = (CONST int *) keyPtr; register CONST int *iPtr2 = (CONST int *) hPtr->key.words; @@ -914,9 +907,9 @@ CompareArrayKeys(keyPtr, hPtr) */ static unsigned int -HashArrayKey(tablePtr, keyPtr) - Tcl_HashTable *tablePtr; /* Hash table. */ - VOID *keyPtr; /* Key from which to compute hash value. */ +HashArrayKey( + Tcl_HashTable *tablePtr, /* Hash table. */ + VOID *keyPtr) /* Key from which to compute hash value. */ { register CONST int *array = (CONST int *) keyPtr; register unsigned int result; @@ -946,9 +939,9 @@ HashArrayKey(tablePtr, keyPtr) */ static Tcl_HashEntry * -AllocStringEntry(tablePtr, keyPtr) - Tcl_HashTable *tablePtr; /* Hash table. */ - VOID *keyPtr; /* Key to store in the hash table entry. */ +AllocStringEntry( + Tcl_HashTable *tablePtr, /* Hash table. */ + VOID *keyPtr) /* Key to store in the hash table entry. */ { CONST char *string = (CONST char *) keyPtr; Tcl_HashEntry *hPtr; @@ -982,9 +975,9 @@ AllocStringEntry(tablePtr, keyPtr) */ static int -CompareStringKeys(keyPtr, hPtr) - VOID *keyPtr; /* New key to compare. */ - Tcl_HashEntry *hPtr; /* Existing key to compare. */ +CompareStringKeys( + VOID *keyPtr, /* New key to compare. */ + Tcl_HashEntry *hPtr) /* Existing key to compare. */ { register CONST char *p1 = (CONST char *) keyPtr; register CONST char *p2 = (CONST char *) hPtr->key.string; @@ -1022,9 +1015,9 @@ CompareStringKeys(keyPtr, hPtr) */ static unsigned int -HashStringKey(tablePtr, keyPtr) - Tcl_HashTable *tablePtr; /* Hash table. */ - VOID *keyPtr; /* Key from which to compute hash value. */ +HashStringKey( + Tcl_HashTable *tablePtr, /* Hash table. */ + VOID *keyPtr) /* Key from which to compute hash value. */ { register CONST char *string = (CONST char *) keyPtr; register unsigned int result; @@ -1075,9 +1068,9 @@ HashStringKey(tablePtr, keyPtr) /* ARGSUSED */ static Tcl_HashEntry * -BogusFind(tablePtr, key) - Tcl_HashTable *tablePtr; /* Table in which to lookup entry. */ - CONST char *key; /* Key to use to find matching entry. */ +BogusFind( + Tcl_HashTable *tablePtr, /* Table in which to lookup entry. */ + CONST char *key) /* Key to use to find matching entry. */ { Tcl_Panic("called Tcl_FindHashEntry on deleted table"); return NULL; @@ -1102,11 +1095,11 @@ BogusFind(tablePtr, key) /* ARGSUSED */ static Tcl_HashEntry * -BogusCreate(tablePtr, key, newPtr) - Tcl_HashTable *tablePtr; /* Table in which to lookup entry. */ - CONST char *key; /* Key to use to find or create matching +BogusCreate( + Tcl_HashTable *tablePtr, /* Table in which to lookup entry. */ + CONST char *key, /* Key to use to find or create matching * entry. */ - int *newPtr; /* Store info here telling whether a new entry + int *newPtr) /* Store info here telling whether a new entry * was created. */ { Tcl_Panic("called Tcl_CreateHashEntry on deleted table"); @@ -1133,8 +1126,8 @@ BogusCreate(tablePtr, key, newPtr) */ static void -RebuildTable(tablePtr) - register Tcl_HashTable *tablePtr; /* Table to enlarge. */ +RebuildTable( + register Tcl_HashTable *tablePtr) /* Table to enlarge. */ { int oldSize, count, index; Tcl_HashEntry **oldBuckets; 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; diff --git a/generic/tclLoad.c b/generic/tclLoad.c index 72c33d4..b8a8b2c 100644 --- a/generic/tclLoad.c +++ b/generic/tclLoad.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclLoad.c,v 1.14 2005/07/17 21:17:43 dkf Exp $ + * RCS: @(#) $Id: tclLoad.c,v 1.15 2005/10/31 15:59:41 dkf Exp $ */ #include "tclInt.h" @@ -17,8 +17,8 @@ /* * The following structure describes a package that has been loaded either * dynamically (with the "load" command) or statically (as indicated by a call - * to TclGetLoadedPackages). All such packages are linked together into a - * single list for the process. Packages are never unloaded, until the + * to TclGetLoadedPackages). All such packages are linked together into a + * single list for the process. Packages are never unloaded, until the * application exits, when TclFinalizeLoad is called, and these structures are * freed. */ @@ -33,24 +33,24 @@ typedef struct LoadedPackage { * Malloc-ed. */ Tcl_LoadHandle loadHandle; /* Token for the loaded file which should be * passed to (*unLoadProcPtr)() when the file - * is no longer needed. If fileName is NULL, + * is no longer needed. If fileName is NULL, * then this field is irrelevant. */ Tcl_PackageInitProc *initProc; - /* Initialization procedure to call to + /* Initialization function to call to * incorporate this package into a trusted * interpreter. */ Tcl_PackageInitProc *safeInitProc; - /* Initialization procedure to call to + /* Initialization function to call to * incorporate this package into a safe * interpreter (one that will execute * untrusted scripts). NULL means the package * can't be used in unsafe interpreters. */ Tcl_PackageUnloadProc *unloadProc; - /* Finalisation procedure to unload a package + /* Finalisation function to unload a package * from a trusted interpreter. NULL means that * the package cannot be unloaded. */ Tcl_PackageUnloadProc *safeUnloadProc; - /* Finalisation procedure to unload a package + /* Finalisation function to unload a package * from a safe interpreter. NULL means that * the package cannot be unloaded. */ int interpRefCount; /* How many times the package has been loaded @@ -58,10 +58,10 @@ typedef struct LoadedPackage { int safeInterpRefCount; /* How many times the package has been loaded * in safe interpreters. */ Tcl_FSUnloadFileProc *unLoadProcPtr; - /* Procedure to use to unload this package. - * If NULL, then we do not attempt to unload - * the package. If fileName is NULL, then - * this field is irrelevant. */ + /* Function to use to unload this package. If + * NULL, then we do not attempt to unload the + * package. If fileName is NULL, then this + * field is irrelevant. */ struct LoadedPackage *nextPtr; /* Next in list of all packages loaded into * this application process. NULL means end of @@ -83,7 +83,7 @@ TCL_DECLARE_MUTEX(packageMutex) /* * The following structure represents a particular package that has been * incorporated into a particular interpreter (by calling its initialization - * procedure). There is a list of these structures for each interpreter, with + * function). There is a list of these structures for each interpreter, with * an AssocData value (key "load") for the interpreter that points to the * first package (if any). */ @@ -97,18 +97,18 @@ typedef struct InterpPackage { } InterpPackage; /* - * Prototypes for procedures that are private to this file: + * Prototypes for functions that are private to this file: */ -static void LoadCleanupProc _ANSI_ARGS_((ClientData clientData, - Tcl_Interp *interp)); +static void LoadCleanupProc(ClientData clientData, + Tcl_Interp *interp); /* *---------------------------------------------------------------------- * * Tcl_LoadObjCmd -- * - * This procedure is invoked to process the "load" Tcl command. See the + * This function is invoked to process the "load" Tcl command. See the * user documentation for details on what it does. * * Results: @@ -121,11 +121,11 @@ static void LoadCleanupProc _ANSI_ARGS_((ClientData clientData, */ int -Tcl_LoadObjCmd(dummy, interp, objc, objv) - ClientData dummy; /* Not used. */ - Tcl_Interp *interp; /* Current interpreter. */ - int objc; /* Number of arguments. */ - Tcl_Obj *CONST objv[]; /* Argument objects. */ +Tcl_LoadObjCmd( + ClientData dummy, /* Not used. */ + Tcl_Interp *interp, /* Current interpreter. */ + int objc, /* Number of arguments. */ + Tcl_Obj *CONST objv[]) /* Argument objects. */ { Tcl_Interp *target; LoadedPackage *pkgPtr, *defaultPtr; @@ -190,7 +190,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) /* * Scan through the packages that are currently loaded to see if the - * package we want is already loaded. We'll use a loaded package if it + * package we want is already loaded. We'll use a loaded package if it * meets any of the following conditions: * - Its name and file match the once we're looking for. * - Its file matches, and we weren't given a name. @@ -234,7 +234,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) Tcl_AppendResult(interp, "file \"", fullFileName, "\" is already loaded for package \"", - pkgPtr->packageName, "\"", (char *) NULL); + pkgPtr->packageName, "\"", NULL); code = TCL_ERROR; Tcl_MutexUnlock(&packageMutex); goto done; @@ -247,13 +247,13 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) /* * Scan through the list of packages already loaded in the target - * interpreter. If the package we want is already loaded there, then + * interpreter. If the package we want is already loaded there, then * there's nothing for us to do. */ if (pkgPtr != NULL) { - ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", - (Tcl_InterpDeleteProc **) NULL); + ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, + "tclLoad", NULL); for (ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { if (ipPtr->pkgPtr == pkgPtr) { code = TCL_OK; @@ -270,7 +270,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) if (fullFileName[0] == 0) { Tcl_AppendResult(interp, "package \"", packageName, - "\" isn't loaded statically", (char *) NULL); + "\" isn't loaded statically", NULL); code = TCL_ERROR; goto done; } @@ -322,7 +322,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) Tcl_DecrRefCount(splitPtr); Tcl_AppendResult(interp, "couldn't figure out package name for ", - fullFileName, (char *) NULL); + fullFileName, NULL); code = TCL_ERROR; goto done; } @@ -341,8 +341,8 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) Tcl_UtfToTitle(Tcl_DStringValue(&pkgName))); /* - * Compute the names of the two initialization procedures, based on - * the package name. + * Compute the names of the two initialization functions, based on the + * package name. */ Tcl_DStringAppend(&initName, Tcl_DStringValue(&pkgName), -1); @@ -356,7 +356,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) /* * Call platform-specific code to load the package and find the two - * initialization procedures. + * initialization functions. */ symbols[0] = Tcl_DStringValue(&initName); @@ -379,7 +379,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) if (*procPtrs[0] /* initProc */ == NULL) { Tcl_AppendResult(interp, "couldn't find procedure ", - Tcl_DStringValue(&initName), (char *) NULL); + Tcl_DStringValue(&initName), NULL); if (unLoadProcPtr != NULL) { (*unLoadProcPtr)(loadHandle); } @@ -414,7 +414,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) } /* - * Invoke the package's initialization procedure (either the normal one or + * Invoke the package's initialization function (either the normal one or * the safe one, depending on whether or not the interpreter is safe). */ @@ -424,7 +424,7 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) } else { Tcl_AppendResult(interp, "can't use package in a safe interpreter: no ", - pkgPtr->packageName, "_SafeInit procedure", (char *) NULL); + pkgPtr->packageName, "_SafeInit procedure", NULL); code = TCL_ERROR; goto done; } @@ -455,8 +455,8 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) * additional static packages at the head of the linked list! */ - ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", - (Tcl_InterpDeleteProc **) NULL); + ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, + "tclLoad", NULL); ipPtr = (InterpPackage *) ckalloc(sizeof(InterpPackage)); ipPtr->pkgPtr = pkgPtr; ipPtr->nextPtr = ipFirstPtr; @@ -481,8 +481,8 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) * * Tcl_UnloadObjCmd -- * - * This procedure is invoked to process the "unload" Tcl command. See - * the user documentation for details on what it does. + * This function is invoked to process the "unload" Tcl command. See the + * user documentation for details on what it does. * * Results: * A standard Tcl result. @@ -494,11 +494,11 @@ Tcl_LoadObjCmd(dummy, interp, objc, objv) */ int -Tcl_UnloadObjCmd(dummy, interp, objc, objv) - ClientData dummy; /* Not used. */ - Tcl_Interp *interp; /* Current interpreter. */ - int objc; /* Number of arguments. */ - Tcl_Obj *CONST objv[]; /* Argument objects. */ +Tcl_UnloadObjCmd( + ClientData dummy, /* Not used. */ + Tcl_Interp *interp, /* Current interpreter. */ + int objc, /* Number of arguments. */ + Tcl_Obj *CONST objv[]) /* Argument objects. */ { Tcl_Interp *target; /* Which interpreter to unload from. */ LoadedPackage *pkgPtr, *defaultPtr; @@ -593,7 +593,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) /* * Scan through the packages that are currently loaded to see if the - * package we want is already loaded. We'll use a loaded package if it + * package we want is already loaded. We'll use a loaded package if it * meets any of the following conditions: * - Its name and file match the once we're looking for. * - Its file matches, and we weren't given a name. @@ -643,8 +643,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) */ Tcl_AppendResult(interp, "package \"", packageName, - "\" is loaded statically and cannot be unloaded", - (char *) NULL); + "\" is loaded statically and cannot be unloaded", NULL); code = TCL_ERROR; goto done; } @@ -654,21 +653,21 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) */ Tcl_AppendResult(interp, "file \"", fullFileName, - "\" has never been loaded", (char *) NULL); + "\" has never been loaded", NULL); code = TCL_ERROR; goto done; } /* * Scan through the list of packages already loaded in the target - * interpreter. If the package we want is already loaded there, then we + * interpreter. If the package we want is already loaded there, then we * should proceed with unloading. */ code = TCL_ERROR; if (pkgPtr != NULL) { - ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", - (Tcl_InterpDeleteProc **) NULL); + ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, + "tclLoad", NULL); for (ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { if (ipPtr->pkgPtr == pkgPtr) { code = TCL_OK; @@ -682,7 +681,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) */ Tcl_AppendResult(interp, "file \"", fullFileName, - "\" has never been loaded in this interpreter", (char *) NULL); + "\" has never been loaded in this interpreter", NULL); code = TCL_ERROR; goto done; } @@ -696,8 +695,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) if (Tcl_IsSafe(target)) { if (pkgPtr->safeUnloadProc == NULL) { Tcl_AppendResult(interp, "file \"", fullFileName, - "\" cannot be unloaded under a safe interpreter", - (char *) NULL); + "\" cannot be unloaded under a safe interpreter", NULL); code = TCL_ERROR; goto done; } @@ -705,8 +703,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) } else { if (pkgPtr->unloadProc == NULL) { Tcl_AppendResult(interp, "file \"", fullFileName, - "\" cannot be unloaded under a trusted interpreter", - (char *) NULL); + "\" cannot be unloaded under a trusted interpreter", NULL); code = TCL_ERROR; goto done; } @@ -715,7 +712,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) /* * We are ready to unload the package. First, evaluate the unload - * procedure. If this fails, we cannot proceed with unload. Also, we must + * function. If this fails, we cannot proceed with unload. Also, we must * specify the proper flag to pass to the unload callback. * TCL_UNLOAD_DETACH_FROM_INTERPRETER is defined when the callback should * only remove itself from the interpreter; the library will be unloaded @@ -747,7 +744,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) } /* - * The unload procedure executed fine. Examine the reference count to see + * The unload function executed fine. Examine the reference count to see * if we unload the DLL. */ @@ -821,7 +818,7 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) */ ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target, - "tclLoad", (Tcl_InterpDeleteProc **) NULL); + "tclLoad", NULL); ipPtr = ipFirstPtr; if (ipPtr->pkgPtr == defaultPtr) { ipFirstPtr = ipFirstPtr->nextPtr; @@ -846,13 +843,13 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) } else { Tcl_AppendResult(interp, "file \"", fullFileName, "\" cannot be unloaded: filesystem does not support unloading", - (char *) NULL); + NULL); code = TCL_ERROR; } } #else Tcl_AppendResult(interp, "file \"", fullFileName, - "\" cannot be unloaded: unloading disabled", (char *) NULL); + "\" cannot be unloaded: unloading disabled", NULL); code = TCL_ERROR; #endif } @@ -902,33 +899,33 @@ Tcl_UnloadObjCmd(dummy, interp, objc, objv) * * Tcl_StaticPackage -- * - * This procedure is invoked to indicate that a particular package has + * This function is invoked to indicate that a particular package has * been linked statically with an application. * * Results: * None. * * Side effects: - * Once this procedure completes, the package becomes loadable via the + * Once this function completes, the package becomes loadable via the * "load" command with an empty file name. * *---------------------------------------------------------------------- */ void -Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) - Tcl_Interp *interp; /* If not NULL, it means that the package has +Tcl_StaticPackage( + Tcl_Interp *interp, /* If not NULL, it means that the package has * already been loaded into the given * interpreter by calling the appropriate init * proc. */ - CONST char *pkgName; /* Name of package (must be properly + CONST char *pkgName, /* Name of package (must be properly * capitalized: first letter upper case, * others lower case). */ - Tcl_PackageInitProc *initProc; - /* Procedure to call to incorporate this + Tcl_PackageInitProc *initProc, + /* Function to call to incorporate this * package into a trusted interpreter. */ - Tcl_PackageInitProc *safeInitProc; - /* Procedure to call to incorporate this + Tcl_PackageInitProc *safeInitProc) + /* Function to call to incorporate this * package into a safe interpreter (one that * will execute untrusted scripts). NULL means * the package can't be used in safe @@ -961,8 +958,8 @@ Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) pkgPtr = (LoadedPackage *) ckalloc(sizeof(LoadedPackage)); pkgPtr->fileName = (char *) ckalloc((unsigned) 1); pkgPtr->fileName[0] = 0; - pkgPtr->packageName = (char *) ckalloc((unsigned) - (strlen(pkgName) + 1)); + pkgPtr->packageName = (char *) + ckalloc((unsigned) (strlen(pkgName) + 1)); strcpy(pkgPtr->packageName, pkgName); pkgPtr->loadHandle = NULL; pkgPtr->initProc = initProc; @@ -980,8 +977,8 @@ Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) * it's already loaded. */ - ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(interp, "tclLoad", - (Tcl_InterpDeleteProc **) NULL); + ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(interp, + "tclLoad", NULL); for ( ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr ) { if ( ipPtr->pkgPtr == pkgPtr ) { return; @@ -1006,7 +1003,7 @@ Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) * * TclGetLoadedPackages -- * - * This procedure returns information about all of the files that are + * This function returns information about all of the files that are * loaded (either in a particular intepreter, or for all interpreters). * * Results: @@ -1023,10 +1020,10 @@ Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) */ int -TclGetLoadedPackages(interp, targetName) - Tcl_Interp *interp; /* Interpreter in which to return information +TclGetLoadedPackages( + Tcl_Interp *interp, /* Interpreter in which to return information * or error message. */ - char *targetName; /* Name of target interpreter or NULL. If + char *targetName) /* Name of target interpreter or NULL. If * NULL, return info about all interps; * otherwise, just return info about this * interpreter. */ @@ -1045,10 +1042,10 @@ TclGetLoadedPackages(interp, targetName) Tcl_MutexLock(&packageMutex); for (pkgPtr = firstPackagePtr; pkgPtr != NULL; pkgPtr = pkgPtr->nextPtr) { - Tcl_AppendResult(interp, prefix, (char *) NULL); + Tcl_AppendResult(interp, prefix, NULL); Tcl_AppendElement(interp, pkgPtr->fileName); Tcl_AppendElement(interp, pkgPtr->packageName); - Tcl_AppendResult(interp, "}", (char *) NULL); + Tcl_AppendResult(interp, "}", NULL); prefix = " {"; } Tcl_MutexUnlock(&packageMutex); @@ -1064,15 +1061,14 @@ TclGetLoadedPackages(interp, targetName) if (target == NULL) { return TCL_ERROR; } - ipPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", - (Tcl_InterpDeleteProc **) NULL); + ipPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", NULL); prefix = "{"; for ( ; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { pkgPtr = ipPtr->pkgPtr; - Tcl_AppendResult(interp, prefix, (char *) NULL); + Tcl_AppendResult(interp, prefix, NULL); Tcl_AppendElement(interp, pkgPtr->fileName); Tcl_AppendElement(interp, pkgPtr->packageName); - Tcl_AppendResult(interp, "}", (char *) NULL); + Tcl_AppendResult(interp, "}", NULL); prefix = " {"; } return TCL_OK; @@ -1083,7 +1079,7 @@ TclGetLoadedPackages(interp, targetName) * * LoadCleanupProc -- * - * This procedure is called to delete all of the InterpPackage structures + * This function is called to delete all of the InterpPackage structures * for an interpreter when the interpreter is deleted. It gets invoked * via the Tcl AssocData mechanism. * @@ -1091,17 +1087,16 @@ TclGetLoadedPackages(interp, targetName) * None. * * Side effects: - * Storage for all of the InterpPackage procedures for interp get - * deleted. + * Storage for all of the InterpPackage functions for interp get deleted. * *---------------------------------------------------------------------- */ static void -LoadCleanupProc(clientData, interp) - ClientData clientData; /* Pointer to first InterpPackage structure +LoadCleanupProc( + ClientData clientData, /* Pointer to first InterpPackage structure * for interp. */ - Tcl_Interp *interp; /* Interpreter that is being deleted. */ + Tcl_Interp *interp) /* Interpreter that is being deleted. */ { InterpPackage *ipPtr, *nextPtr; @@ -1118,7 +1113,7 @@ LoadCleanupProc(clientData, interp) * * TclFinalizeLoad -- * - * This procedure is invoked just before the application exits. It frees + * This function is invoked just before the application exits. It frees * all of the LoadedPackage structures. * * Results: @@ -1131,7 +1126,7 @@ LoadCleanupProc(clientData, interp) */ void -TclFinalizeLoad() +TclFinalizeLoad(void) { LoadedPackage *pkgPtr; @@ -1151,7 +1146,7 @@ TclFinalizeLoad() * Some Unix dlls are poorly behaved - registering things like atexit * calls that can't be unregistered. If you unload such dlls, you get * a core on exit because it wants to call a function in the dll after - * it's been unloaded. + * it has been unloaded. */ if (pkgPtr->fileName[0] != '\0') { diff --git a/generic/tclParseExpr.c b/generic/tclParseExpr.c index 589dd49..27d980e 100644 --- a/generic/tclParseExpr.c +++ b/generic/tclParseExpr.c @@ -12,7 +12,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclParseExpr.c,v 1.29 2005/10/19 18:39:58 dgp Exp $ + * RCS: @(#) $Id: tclParseExpr.c,v 1.30 2005/10/31 15:59:41 dkf Exp $ */ #include "tclInt.h" @@ -140,26 +140,26 @@ static char *lexemeStrings[] = { * Declarations for local functions to this file: */ -static int GetLexeme _ANSI_ARGS_((ParseInfo *infoPtr)); -static void LogSyntaxError _ANSI_ARGS_((ParseInfo *infoPtr, - CONST char *extraInfo)); -static int ParseAddExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseBitAndExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseBitOrExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseBitXorExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseCondExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseEqualityExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseLandExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseLorExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseMultiplyExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParsePrimaryExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseRelationalExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseShiftExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseExponentialExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static int ParseUnaryExpr _ANSI_ARGS_((ParseInfo *infoPtr)); -static void PrependSubExprTokens _ANSI_ARGS_((CONST char *op, - int opBytes, CONST char *src, int srcBytes, - int firstIndex, ParseInfo *infoPtr)); +static int GetLexeme(ParseInfo *infoPtr); +static void LogSyntaxError(ParseInfo *infoPtr, + CONST char *extraInfo); +static int ParseAddExpr(ParseInfo *infoPtr); +static int ParseBitAndExpr(ParseInfo *infoPtr); +static int ParseBitOrExpr(ParseInfo *infoPtr); +static int ParseBitXorExpr(ParseInfo *infoPtr); +static int ParseCondExpr(ParseInfo *infoPtr); +static int ParseEqualityExpr(ParseInfo *infoPtr); +static int ParseLandExpr(ParseInfo *infoPtr); +static int ParseLorExpr(ParseInfo *infoPtr); +static int ParseMultiplyExpr(ParseInfo *infoPtr); +static int ParsePrimaryExpr(ParseInfo *infoPtr); +static int ParseRelationalExpr(ParseInfo *infoPtr); +static int ParseShiftExpr(ParseInfo *infoPtr); +static int ParseExponentialExpr(ParseInfo *infoPtr); +static int ParseUnaryExpr(ParseInfo *infoPtr); +static void PrependSubExprTokens(CONST char *op, int opBytes, + CONST char *src, int srcBytes, int firstIndex, + ParseInfo *infoPtr); /* * Macro used to debug the execution of the recursive descent parser used to @@ -207,13 +207,13 @@ static void PrependSubExprTokens _ANSI_ARGS_((CONST char *op, */ int -Tcl_ParseExpr(interp, start, numBytes, parsePtr) - Tcl_Interp *interp; /* Used for error reporting. */ - CONST char *start; /* Start of source string to parse. */ - int numBytes; /* Number of bytes in string. If < 0, the +Tcl_ParseExpr( + Tcl_Interp *interp, /* Used for error reporting. */ + CONST char *start, /* Start of source string to parse. */ + int numBytes, /* Number of bytes in string. If < 0, the * string consists of all bytes up to the * first null character. */ - Tcl_Parse *parsePtr; /* Structure to fill with information about + Tcl_Parse *parsePtr) /* Structure to fill with information about * the parsed expression; any previous * information in the structure is ignored. */ { @@ -298,8 +298,8 @@ Tcl_ParseExpr(interp, start, numBytes, parsePtr) */ static int -ParseCondExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseCondExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -411,8 +411,8 @@ ParseCondExpr(infoPtr) */ static int -ParseLorExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseLorExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -470,8 +470,8 @@ ParseLorExpr(infoPtr) */ static int -ParseLandExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseLandExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -529,8 +529,8 @@ ParseLandExpr(infoPtr) */ static int -ParseBitOrExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseBitOrExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -589,8 +589,8 @@ ParseBitOrExpr(infoPtr) */ static int -ParseBitXorExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseBitXorExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -649,8 +649,8 @@ ParseBitXorExpr(infoPtr) */ static int -ParseBitAndExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseBitAndExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -709,8 +709,8 @@ ParseBitAndExpr(infoPtr) */ static int -ParseEqualityExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseEqualityExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -772,8 +772,8 @@ ParseEqualityExpr(infoPtr) */ static int -ParseRelationalExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseRelationalExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -839,8 +839,8 @@ ParseRelationalExpr(infoPtr) */ static int -ParseShiftExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseShiftExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -900,8 +900,8 @@ ParseShiftExpr(infoPtr) */ static int -ParseAddExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseAddExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -961,8 +961,8 @@ ParseAddExpr(infoPtr) */ static int -ParseMultiplyExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseMultiplyExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -1022,8 +1022,8 @@ ParseMultiplyExpr(infoPtr) */ static int -ParseExponentialExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseExponentialExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -1083,8 +1083,8 @@ ParseExponentialExpr(infoPtr) */ static int -ParseUnaryExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParseUnaryExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -1130,7 +1130,7 @@ ParseUnaryExpr(infoPtr) * * This function parses a Tcl primary expression: * primaryExpr ::= literal | varReference | quotedString | - * '[' command ']' | mathFuncCall | '(' condExpr ')' + * '[' command ']' | mathFuncCall | '(' condExpr ')' * * Results: * The return value is TCL_OK on a successful parse and TCL_ERROR on @@ -1145,8 +1145,8 @@ ParseUnaryExpr(infoPtr) */ static int -ParsePrimaryExpr(infoPtr) - ParseInfo *infoPtr; /* Holds the parse state for the expression +ParsePrimaryExpr( + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -1564,8 +1564,8 @@ ParsePrimaryExpr(infoPtr) */ static int -GetLexeme(infoPtr) - ParseInfo *infoPtr; /* Holds state needed to parse the expr, +GetLexeme( + ParseInfo *infoPtr) /* Holds state needed to parse the expr, * including the resulting lexeme. */ { register CONST char *src; /* Points to current source char. */ @@ -1615,11 +1615,12 @@ GetLexeme(infoPtr) if ((c != '+') && (c != '-')) { CONST char *end = infoPtr->lastChar; CONST char* end2; - int code = TclParseNumber(NULL, NULL, NULL, - src, (unsigned)(end-src), &end2, 0); - if ( code == TCL_OK ) { + int code = TclParseNumber(NULL, NULL, NULL, src, (unsigned)(end-src), + &end2, 0); + + if (code == TCL_OK) { length = end2-src; - if ( length > 0 ) { + if (length > 0) { infoPtr->lexeme = LITERAL; infoPtr->start = src; infoPtr->size = length; @@ -1892,17 +1893,17 @@ GetLexeme(infoPtr) */ static void -PrependSubExprTokens(op, opBytes, src, srcBytes, firstIndex, infoPtr) - CONST char *op; /* Points to first byte of the operator in the +PrependSubExprTokens( + CONST char *op, /* Points to first byte of the operator in the * source script. */ - int opBytes; /* Number of bytes in the operator. */ - CONST char *src; /* Points to first byte of the subexpression + int opBytes, /* Number of bytes in the operator. */ + CONST char *src, /* Points to first byte of the subexpression * in the source script. */ - int srcBytes; /* Number of bytes in subexpression's + int srcBytes, /* Number of bytes in subexpression's * source. */ - int firstIndex; /* Index of first token already emitted for + int firstIndex, /* Index of first token already emitted for * operator's first (or only) operand. */ - ParseInfo *infoPtr; /* Holds the parse state for the expression + ParseInfo *infoPtr) /* Holds the parse state for the expression * being parsed. */ { Tcl_Parse *parsePtr = infoPtr->parsePtr; @@ -1953,17 +1954,18 @@ PrependSubExprTokens(op, opBytes, src, srcBytes, firstIndex, infoPtr) */ static void -LogSyntaxError(infoPtr, extraInfo) - ParseInfo *infoPtr; /* Holds the parse state for the expression +LogSyntaxError( + ParseInfo *infoPtr, /* Holds the parse state for the expression * being parsed. */ - CONST char *extraInfo; /* String to provide extra information about + CONST char *extraInfo) /* String to provide extra information about * the syntax error. */ { Tcl_Obj *result = Tcl_NewStringObj("syntax error in expression \"", -1); + TclAppendLimitedToObj(result, infoPtr->originalExpr, (int)(infoPtr->lastChar - infoPtr->originalExpr), 63, NULL); - Tcl_AppendStringsToObj(result, "\": ", extraInfo, (char *) NULL); + Tcl_AppendStringsToObj(result, "\": ", extraInfo, NULL); Tcl_SetObjResult(infoPtr->parsePtr->interp, result); infoPtr->parsePtr->errorType = TCL_PARSE_SYNTAX; infoPtr->parsePtr->term = infoPtr->start; diff --git a/generic/tclTimer.c b/generic/tclTimer.c index faf44b7..5f0b758 100644 --- a/generic/tclTimer.c +++ b/generic/tclTimer.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTimer.c,v 1.19 2005/10/04 18:33:30 vasiljevic Exp $ + * RCS: @(#) $Id: tclTimer.c,v 1.20 2005/10/31 15:59:41 dkf Exp $ */ #include "tclInt.h" @@ -133,21 +133,18 @@ static Tcl_ThreadDataKey dataKey; * Prototypes for functions referenced only in this file: */ -static void AfterCleanupProc _ANSI_ARGS_((ClientData clientData, - Tcl_Interp *interp)); -static int AfterDelay _ANSI_ARGS_((Tcl_Interp *interp, int ms)); -static void AfterProc _ANSI_ARGS_((ClientData clientData)); -static void FreeAfterPtr _ANSI_ARGS_((AfterInfo *afterPtr)); -static AfterInfo * GetAfterEvent _ANSI_ARGS_((AfterAssocData *assocPtr, - Tcl_Obj *commandPtr)); -static ThreadSpecificData *InitTimer _ANSI_ARGS_((void)); -static void TimerExitProc _ANSI_ARGS_((ClientData clientData)); -static int TimerHandlerEventProc _ANSI_ARGS_((Tcl_Event *evPtr, - int flags)); -static void TimerCheckProc _ANSI_ARGS_((ClientData clientData, - int flags)); -static void TimerSetupProc _ANSI_ARGS_((ClientData clientData, - int flags)); +static void AfterCleanupProc(ClientData clientData, + Tcl_Interp *interp); +static int AfterDelay(Tcl_Interp *interp, int ms); +static void AfterProc(ClientData clientData); +static void FreeAfterPtr(AfterInfo *afterPtr); +static AfterInfo * GetAfterEvent(AfterAssocData *assocPtr, + Tcl_Obj *commandPtr); +static ThreadSpecificData *InitTimer(void); +static void TimerExitProc(ClientData clientData); +static int TimerHandlerEventProc(Tcl_Event *evPtr, int flags); +static void TimerCheckProc(ClientData clientData, int flags); +static void TimerSetupProc(ClientData clientData, int flags); /* *---------------------------------------------------------------------- @@ -166,7 +163,7 @@ static void TimerSetupProc _ANSI_ARGS_((ClientData clientData, */ static ThreadSpecificData * -InitTimer() +InitTimer(void) { ThreadSpecificData *tsdPtr = (ThreadSpecificData *) TclThreadDataKeyGet(&dataKey); @@ -197,8 +194,8 @@ InitTimer() */ static void -TimerExitProc(clientData) - ClientData clientData; /* Not used. */ +TimerExitProc( + ClientData clientData) /* Not used. */ { ThreadSpecificData *tsdPtr = (ThreadSpecificData *) TclThreadDataKeyGet(&dataKey); @@ -235,11 +232,11 @@ TimerExitProc(clientData) */ Tcl_TimerToken -Tcl_CreateTimerHandler(milliseconds, proc, clientData) - int milliseconds; /* How many milliseconds to wait before +Tcl_CreateTimerHandler( + int milliseconds, /* How many milliseconds to wait before * invoking proc. */ - Tcl_TimerProc *proc; /* Function to invoke. */ - ClientData clientData; /* Arbitrary data to pass to proc. */ + Tcl_TimerProc *proc, /* Function to invoke. */ + ClientData clientData) /* Arbitrary data to pass to proc. */ { Tcl_Time time; @@ -277,10 +274,10 @@ Tcl_CreateTimerHandler(milliseconds, proc, clientData) */ Tcl_TimerToken -TclCreateAbsoluteTimerHandler(timePtr, proc, clientData) - Tcl_Time *timePtr; - Tcl_TimerProc *proc; - ClientData clientData; +TclCreateAbsoluteTimerHandler( + Tcl_Time *timePtr, + Tcl_TimerProc *proc, + ClientData clientData) { register TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr; ThreadSpecificData *tsdPtr; @@ -340,8 +337,8 @@ TclCreateAbsoluteTimerHandler(timePtr, proc, clientData) */ void -Tcl_DeleteTimerHandler(token) - Tcl_TimerToken token; /* Result previously returned by +Tcl_DeleteTimerHandler( + Tcl_TimerToken token) /* Result previously returned by * Tcl_DeleteTimerHandler. */ { register TimerHandler *timerHandlerPtr, *prevPtr; @@ -386,9 +383,9 @@ Tcl_DeleteTimerHandler(token) */ static void -TimerSetupProc(data, flags) - ClientData data; /* Not used. */ - int flags; /* Event flags as passed to Tcl_DoOneEvent. */ +TimerSetupProc( + ClientData data, /* Not used. */ + int flags) /* Event flags as passed to Tcl_DoOneEvent. */ { Tcl_Time blockTime; ThreadSpecificData *tsdPtr = InitTimer(); @@ -445,9 +442,9 @@ TimerSetupProc(data, flags) */ static void -TimerCheckProc(data, flags) - ClientData data; /* Not used. */ - int flags; /* Event flags as passed to Tcl_DoOneEvent. */ +TimerCheckProc( + ClientData data, /* Not used. */ + int flags) /* Event flags as passed to Tcl_DoOneEvent. */ { Tcl_Event *timerEvPtr; Tcl_Time blockTime; @@ -507,9 +504,9 @@ TimerCheckProc(data, flags) */ static int -TimerHandlerEventProc(evPtr, flags) - Tcl_Event *evPtr; /* Event to service. */ - int flags; /* Flags that indicate what events to handle, +TimerHandlerEventProc( + Tcl_Event *evPtr, /* Event to service. */ + int flags) /* Flags that indicate what events to handle, * such as TCL_FILE_EVENTS. */ { TimerHandler *timerHandlerPtr, **nextPtrPtr; @@ -607,9 +604,9 @@ TimerHandlerEventProc(evPtr, flags) */ void -Tcl_DoWhenIdle(proc, clientData) - Tcl_IdleProc *proc; /* Function to invoke. */ - ClientData clientData; /* Arbitrary value to pass to proc. */ +Tcl_DoWhenIdle( + Tcl_IdleProc *proc, /* Function to invoke. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ { register IdleHandler *idlePtr; Tcl_Time blockTime; @@ -651,9 +648,9 @@ Tcl_DoWhenIdle(proc, clientData) */ void -Tcl_CancelIdleCall(proc, clientData) - Tcl_IdleProc *proc; /* Function that was previously registered. */ - ClientData clientData; /* Arbitrary value to pass to proc. */ +Tcl_CancelIdleCall( + Tcl_IdleProc *proc, /* Function that was previously registered. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ { register IdleHandler *idlePtr, *prevPtr; IdleHandler *nextPtr; @@ -699,7 +696,7 @@ Tcl_CancelIdleCall(proc, clientData) */ int -TclServiceIdle() +TclServiceIdle(void) { IdleHandler *idlePtr; int oldGeneration; @@ -768,11 +765,11 @@ TclServiceIdle() /* ARGSUSED */ int -Tcl_AfterObjCmd(clientData, interp, objc, objv) - ClientData clientData; /* Unused */ - Tcl_Interp *interp; /* Current interpreter. */ - int objc; /* Number of arguments. */ - Tcl_Obj *CONST objv[]; /* Argument objects. */ +Tcl_AfterObjCmd( + ClientData clientData, /* Unused */ + Tcl_Interp *interp, /* Current interpreter. */ + int objc, /* Number of arguments. */ + Tcl_Obj *CONST objv[]) /* Argument objects. */ { int ms; AfterInfo *afterPtr; @@ -782,7 +779,7 @@ Tcl_AfterObjCmd(clientData, interp, objc, objv) int index; char buf[16 + TCL_INTEGER_SPACE]; static CONST char *afterSubCmds[] = { - "cancel", "idle", "info", (char *) NULL + "cancel", "idle", "info", NULL }; Tcl_Obj *objPtr; enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO}; @@ -866,8 +863,7 @@ Tcl_AfterObjCmd(clientData, interp, objc, objv) if (Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "argument", 0, &index) != TCL_OK) { Tcl_AppendResult(interp, "bad argument \"", argString, - "\": must be cancel, idle, info, or a number", - (char *) NULL); + "\": must be cancel, idle, info, or a number", NULL); return TCL_ERROR; } switch ((enum afterSubCmds) index) { @@ -954,8 +950,8 @@ Tcl_AfterObjCmd(clientData, interp, objc, objv) } afterPtr = GetAfterEvent(assocPtr, objv[2]); if (afterPtr == NULL) { - Tcl_AppendResult(interp, "event \"", Tcl_GetString(objv[2]), - "\" doesn't exist", (char *) NULL); + Tcl_AppendResult(interp, "event \"", TclGetString(objv[2]), + "\" doesn't exist", NULL); return TCL_ERROR; } resultListPtr = Tcl_NewObj(); @@ -990,9 +986,9 @@ Tcl_AfterObjCmd(clientData, interp, objc, objv) */ static int -AfterDelay(interp, ms) - Tcl_Interp *interp; - int ms; +AfterDelay( + Tcl_Interp *interp, + int ms) { Interp *iPtr = (Interp *) interp; @@ -1051,10 +1047,10 @@ AfterDelay(interp, ms) */ static AfterInfo * -GetAfterEvent(assocPtr, commandPtr) - AfterAssocData *assocPtr; /* Points to "after"-related information for +GetAfterEvent( + AfterAssocData *assocPtr, /* Points to "after"-related information for * this interpreter. */ - Tcl_Obj *commandPtr; + Tcl_Obj *commandPtr) { char *cmdString; /* Textual identifier for after event, such as * "after#6". */ @@ -1062,7 +1058,7 @@ GetAfterEvent(assocPtr, commandPtr) int id; char *end; - cmdString = Tcl_GetString(commandPtr); + cmdString = TclGetString(commandPtr); if (strncmp(cmdString, "after#", 6) != 0) { return NULL; } @@ -1100,8 +1096,8 @@ GetAfterEvent(assocPtr, commandPtr) */ static void -AfterProc(clientData) - ClientData clientData; /* Describes command to execute. */ +AfterProc( + ClientData clientData) /* Describes command to execute. */ { AfterInfo *afterPtr = (AfterInfo *) clientData; AfterAssocData *assocPtr = afterPtr->assocPtr; @@ -1133,8 +1129,13 @@ AfterProc(clientData) interp = assocPtr->interp; Tcl_Preserve((ClientData) interp); +#if 0 + /* DKF: Why not just do this? */ + result = Tcl_EvalObjEx(interp, afterPtr->commandPtr, TCL_EVAL_GLOBAL); +#else script = Tcl_GetStringFromObj(afterPtr->commandPtr, &numBytes); result = Tcl_EvalEx(interp, script, numBytes, TCL_EVAL_GLOBAL); +#endif if (result != TCL_OK) { Tcl_AddErrorInfo(interp, "\n (\"after\" script)"); Tcl_BackgroundError(interp); @@ -1168,8 +1169,8 @@ AfterProc(clientData) */ static void -FreeAfterPtr(afterPtr) - AfterInfo *afterPtr; /* Command to be deleted. */ +FreeAfterPtr( + AfterInfo *afterPtr) /* Command to be deleted. */ { AfterInfo *prevPtr; AfterAssocData *assocPtr = afterPtr->assocPtr; @@ -1206,10 +1207,10 @@ FreeAfterPtr(afterPtr) /* ARGSUSED */ static void -AfterCleanupProc(clientData, interp) - ClientData clientData; /* Points to AfterAssocData for the +AfterCleanupProc( + ClientData clientData, /* Points to AfterAssocData for the * interpreter. */ - Tcl_Interp *interp; /* Interpreter that is being deleted. */ + Tcl_Interp *interp) /* Interpreter that is being deleted. */ { AfterAssocData *assocPtr = (AfterAssocData *) clientData; AfterInfo *afterPtr; diff --git a/generic/tclUtf.c b/generic/tclUtf.c index 992a55f..3c86e1b 100644 --- a/generic/tclUtf.c +++ b/generic/tclUtf.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclUtf.c,v 1.36 2005/09/07 15:31:10 dgp Exp $ + * RCS: @(#) $Id: tclUtf.c,v 1.37 2005/10/31 15:59:41 dkf Exp $ */ #include "tclInt.h" @@ -23,7 +23,7 @@ * The following macros are used for fast character category tests. The x_BITS * values are shifted right by the category value to determine whether the * given category is included in the set. - */ + */ #define ALPHA_BITS ((1 << UPPERCASE_LETTER) | (1 << LOWERCASE_LETTER) \ | (1 << TITLECASE_LETTER) | (1 << MODIFIER_LETTER) | (1<<OTHER_LETTER)) @@ -51,15 +51,15 @@ (1 << FINAL_QUOTE_PUNCTUATION) | (1 << OTHER_PUNCTUATION)) /* - * Unicode characters less than this value are represented by themselves - * in UTF-8 strings. + * Unicode characters less than this value are represented by themselves in + * UTF-8 strings. */ #define UNICODE_SELF 0x80 /* - * The following structures are used when mapping between Unicode (UCS-2) - * and UTF-8. + * The following structures are used when mapping between Unicode (UCS-2) and + * UTF-8. */ static CONST unsigned char totalBytes[256] = { @@ -89,10 +89,10 @@ static CONST unsigned char totalBytes[256] = { }; /* - * Procedures used only in this module. + * Functions used only in this module. */ -static int UtfCount _ANSI_ARGS_((int ch)); +static int UtfCount(int ch); /* *--------------------------------------------------------------------------- @@ -109,10 +109,10 @@ static int UtfCount _ANSI_ARGS_((int ch)); * *--------------------------------------------------------------------------- */ - + INLINE static int -UtfCount(ch) - int ch; /* The Tcl_UniChar whose size is returned. */ +UtfCount( + int ch) /* The Tcl_UniChar whose size is returned. */ { if ((ch > 0) && (ch < UNICODE_SELF)) { return 1; @@ -154,12 +154,12 @@ UtfCount(ch) * *--------------------------------------------------------------------------- */ - + INLINE int -Tcl_UniCharToUtf(ch, buf) - int ch; /* The Tcl_UniChar to be stored in the +Tcl_UniCharToUtf( + int ch, /* The Tcl_UniChar to be stored in the * buffer. */ - char *buf; /* Buffer in which the UTF-8 representation of + char *buf) /* Buffer in which the UTF-8 representation of * the Tcl_UniChar is stored. Buffer must be * large enough to hold the UTF-8 character * (at most TCL_UTF_MAX bytes). */ @@ -231,13 +231,13 @@ Tcl_UniCharToUtf(ch, buf) * *--------------------------------------------------------------------------- */ - + char * -Tcl_UniCharToUtfDString(uniStr, uniLength, dsPtr) - CONST Tcl_UniChar *uniStr; /* Unicode string to convert to UTF-8. */ - int uniLength; /* Length of Unicode string in Tcl_UniChars +Tcl_UniCharToUtfDString( + CONST Tcl_UniChar *uniStr, /* Unicode string to convert to UTF-8. */ + int uniLength, /* Length of Unicode string in Tcl_UniChars * (must be >= 0). */ - Tcl_DString *dsPtr; /* UTF-8 representation of string is appended + Tcl_DString *dsPtr) /* UTF-8 representation of string is appended * to this previously initialized DString. */ { CONST Tcl_UniChar *w, *wEnd; @@ -289,15 +289,15 @@ Tcl_UniCharToUtfDString(uniStr, uniLength, dsPtr) * *--------------------------------------------------------------------------- */ - + int -Tcl_UtfToUniChar(src, chPtr) - register CONST char *src; /* The UTF-8 string. */ - register Tcl_UniChar *chPtr; /* Filled with the Tcl_UniChar represented by - * the UTF-8 string. */ +Tcl_UtfToUniChar( + register CONST char *src, /* The UTF-8 string. */ + register Tcl_UniChar *chPtr)/* Filled with the Tcl_UniChar represented by + * the UTF-8 string. */ { register int byte; - + /* * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones. */ @@ -335,7 +335,7 @@ Tcl_UtfToUniChar(src, chPtr) * Three-byte-character lead byte followed by two trail bytes. */ - *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) + *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) | ((src[1] & 0x3F) << 6) | (src[2] & 0x3F)); return 3; } @@ -349,7 +349,7 @@ Tcl_UtfToUniChar(src, chPtr) return 1; } #if TCL_UTF_MAX > 3 - else { + { int ch, total, trail; total = totalBytes[byte]; @@ -395,11 +395,11 @@ Tcl_UtfToUniChar(src, chPtr) */ Tcl_UniChar * -Tcl_UtfToUniCharDString(src, length, dsPtr) - CONST char *src; /* UTF-8 string to convert to Unicode. */ - int length; /* Length of UTF-8 string in bytes, or -1 for +Tcl_UtfToUniCharDString( + CONST char *src, /* UTF-8 string to convert to Unicode. */ + int length, /* Length of UTF-8 string in bytes, or -1 for * strlen(). */ - Tcl_DString *dsPtr; /* Unicode representation of string is + Tcl_DString *dsPtr) /* Unicode representation of string is * appended to this previously initialized * DString. */ { @@ -454,10 +454,10 @@ Tcl_UtfToUniCharDString(src, length, dsPtr) */ int -Tcl_UtfCharComplete(src, length) - CONST char *src; /* String to check if first few bytes contain +Tcl_UtfCharComplete( + CONST char *src, /* String to check if first few bytes contain * a complete UTF-8 character. */ - int length; /* Length of above string in bytes. */ + int length) /* Length of above string in bytes. */ { int ch; @@ -475,18 +475,18 @@ Tcl_UtfCharComplete(src, length) * utflen() and utfnlen(). * * Results: - * As above. + * As above. * * Side effects: * None. * *--------------------------------------------------------------------------- */ - -int -Tcl_NumUtfChars(src, length) - register CONST char *src; /* The UTF-8 string to measure. */ - int length; /* The length of the string in bytes, or -1 + +int +Tcl_NumUtfChars( + register CONST char *src, /* The UTF-8 string to measure. */ + int length) /* The length of the string in bytes, or -1 * for strlen(string). */ { Tcl_UniChar ch; @@ -542,14 +542,15 @@ Tcl_NumUtfChars(src, length) * *--------------------------------------------------------------------------- */ + CONST char * -Tcl_UtfFindFirst(src, ch) - CONST char *src; /* The UTF-8 string to be searched. */ - int ch; /* The Tcl_UniChar to search for. */ +Tcl_UtfFindFirst( + CONST char *src, /* The UTF-8 string to be searched. */ + int ch) /* The Tcl_UniChar to search for. */ { int len; Tcl_UniChar find; - + while (1) { len = TclUtfToUniChar(src, &find); if (find == ch) { @@ -582,14 +583,14 @@ Tcl_UtfFindFirst(src, ch) */ CONST char * -Tcl_UtfFindLast(src, ch) - CONST char *src; /* The UTF-8 string to be searched. */ - int ch; /* The Tcl_UniChar to search for. */ +Tcl_UtfFindLast( + CONST char *src, /* The UTF-8 string to be searched. */ + int ch) /* The Tcl_UniChar to search for. */ { int len; Tcl_UniChar find; CONST char *last; - + last = NULL; while (1) { len = TclUtfToUniChar(src, &find); @@ -622,10 +623,10 @@ Tcl_UtfFindLast(src, ch) * *--------------------------------------------------------------------------- */ - + CONST char * -Tcl_UtfNext(src) - CONST char *src; /* The current location in the string. */ +Tcl_UtfNext( + CONST char *src) /* The current location in the string. */ { Tcl_UniChar ch; @@ -654,14 +655,14 @@ Tcl_UtfNext(src) */ CONST char * -Tcl_UtfPrev(src, start) - CONST char *src; /* The current location in the string. */ - CONST char *start; /* Pointer to the beginning of the string, to +Tcl_UtfPrev( + CONST char *src, /* The current location in the string. */ + CONST char *start) /* Pointer to the beginning of the string, to * avoid going backwards too far. */ { CONST char *look; int i, byte; - + src--; look = src; for (i = 0; i < TCL_UTF_MAX; i++) { @@ -682,7 +683,7 @@ Tcl_UtfPrev(src, start) } return src; } - + /* *--------------------------------------------------------------------------- * @@ -699,11 +700,11 @@ Tcl_UtfPrev(src, start) * *--------------------------------------------------------------------------- */ - + Tcl_UniChar -Tcl_UniCharAtIndex(src, index) - register CONST char *src; /* The UTF-8 string to dereference. */ - register int index; /* The position of the desired character. */ +Tcl_UniCharAtIndex( + register CONST char *src, /* The UTF-8 string to dereference. */ + register int index) /* The position of the desired character. */ { Tcl_UniChar ch; @@ -732,12 +733,12 @@ Tcl_UniCharAtIndex(src, index) */ CONST char * -Tcl_UtfAtIndex(src, index) - register CONST char *src; /* The UTF-8 string. */ - register int index; /* The position of the desired character. */ +Tcl_UtfAtIndex( + register CONST char *src, /* The UTF-8 string. */ + register int index) /* The position of the desired character. */ { Tcl_UniChar ch; - + while (index > 0) { index--; src += TclUtfToUniChar(src, &ch); @@ -772,12 +773,12 @@ Tcl_UtfAtIndex(src, index) */ int -Tcl_UtfBackslash(src, readPtr, dst) - CONST char *src; /* Points to the backslash character of a +Tcl_UtfBackslash( + CONST char *src, /* Points to the backslash character of a * backslash sequence. */ - int *readPtr; /* Fill in with number of characters read from + int *readPtr, /* Fill in with number of characters read from * src, unless NULL. */ - char *dst; /* Filled with the bytes represented by the + char *dst) /* Filled with the bytes represented by the * backslash sequence. */ { #define LINE_LENGTH 128 @@ -786,7 +787,10 @@ Tcl_UtfBackslash(src, readPtr, dst) result = TclParseBackslash(src, LINE_LENGTH, &numRead, dst); if (numRead == LINE_LENGTH) { - /* We ate a whole line. Pay the price of a strlen() */ + /* + * We ate a whole line. Pay the price of a strlen() + */ + result = TclParseBackslash(src, (int)strlen(src), &numRead, dst); } if (readPtr != NULL) { @@ -814,8 +818,8 @@ Tcl_UtfBackslash(src, readPtr, dst) */ int -Tcl_UtfToUpper(str) - char *str; /* String to convert in place. */ +Tcl_UtfToUpper( + char *str) /* String to convert in place. */ { Tcl_UniChar ch, upChar; char *src, *dst; @@ -835,7 +839,7 @@ Tcl_UtfToUpper(str) * conversion (thereby causing a segfault), only copy the upper case * char to dst if its size is <= the original char. */ - + if (bytes < UtfCount(upChar)) { memcpy(dst, src, (size_t) bytes); dst += bytes; @@ -867,13 +871,13 @@ Tcl_UtfToUpper(str) */ int -Tcl_UtfToLower(str) - char *str; /* String to convert in place. */ +Tcl_UtfToLower( + char *str) /* String to convert in place. */ { Tcl_UniChar ch, lowChar; char *src, *dst; int bytes; - + /* * Iterate over the string until we hit the terminating null. */ @@ -888,7 +892,7 @@ Tcl_UtfToLower(str) * conversion (thereby causing a segfault), only copy the lower case * char to dst if its size is <= the original char. */ - + if (bytes < UtfCount(lowChar)) { memcpy(dst, src, (size_t) bytes); dst += bytes; @@ -921,13 +925,13 @@ Tcl_UtfToLower(str) */ int -Tcl_UtfToTitle(str) - char *str; /* String to convert in place. */ +Tcl_UtfToTitle( + char *str) /* String to convert in place. */ { Tcl_UniChar ch, titleChar, lowChar; char *src, *dst; int bytes; - + /* * Capitalize the first character and then lowercase the rest of the * characters until we get to a null. @@ -968,8 +972,8 @@ Tcl_UtfToTitle(str) * * TclpUtfNcmp2 -- * - * Compare at most n bytes of utf-8 strings cs and ct. Both cs and ct are - * assumed to be at least n bytes long. + * Compare at most numBytes bytes of utf-8 strings cs and ct. Both cs and + * ct are assumed to be at least numBytes bytes long. * * Results: * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. @@ -981,26 +985,26 @@ Tcl_UtfToTitle(str) */ int -TclpUtfNcmp2(cs, ct, n) - CONST char *cs; /* UTF string to compare to ct. */ - CONST char *ct; /* UTF string cs is compared to. */ - unsigned long n; /* Number of *bytes* to compare. */ +TclpUtfNcmp2( + CONST char *cs, /* UTF string to compare to ct. */ + CONST char *ct, /* UTF string cs is compared to. */ + unsigned long numBytes) /* Number of *bytes* to compare. */ { /* - * We can't simply call 'memcmp(cs, ct, n);' because we need to check for - * Tcl's \xC0\x80 non-utf-8 null encoding. Otherwise utf-8 lexes fine in - * the strcmp manner. + * We can't simply call 'memcmp(cs, ct, numBytes);' because we need to + * check for Tcl's \xC0\x80 non-utf-8 null encoding. Otherwise utf-8 lexes + * fine in the strcmp manner. */ register int result = 0; - for ( ; n != 0; n--, cs++, ct++) { + for ( ; numBytes != 0; numBytes--, cs++, ct++) { if (*cs != *ct) { result = UCHAR(*cs) - UCHAR(*ct); break; } } - if (n && ((UCHAR(*cs) == 0xC0) || (UCHAR(*ct) == 0xC0))) { + if (numBytes && ((UCHAR(*cs) == 0xC0) || (UCHAR(*ct) == 0xC0))) { unsigned char c1, c2; c1 = ((UCHAR(*cs) == 0xC0) && (UCHAR(cs[1]) == 0x80)) ? 0 : UCHAR(*cs); @@ -1028,10 +1032,10 @@ TclpUtfNcmp2(cs, ct, n) */ int -Tcl_UtfNcmp(cs, ct, numChars) - CONST char *cs; /* UTF string to compare to ct. */ - CONST char *ct; /* UTF string cs is compared to. */ - unsigned long numChars; /* Number of UTF chars to compare. */ +Tcl_UtfNcmp( + CONST char *cs, /* UTF string to compare to ct. */ + CONST char *ct, /* UTF string cs is compared to. */ + unsigned long numChars) /* Number of UTF chars to compare. */ { Tcl_UniChar ch1, ch2; @@ -1063,8 +1067,8 @@ Tcl_UtfNcmp(cs, ct, numChars) * Tcl_UtfNcasecmp -- * * Compare at most numChars UTF chars of string cs to string ct case - * insensitive. Both cs and ct are assumed to be at least numChars - * UTF chars long. + * insensitive. Both cs and ct are assumed to be at least numChars UTF + * chars long. * * Results: * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. @@ -1076,10 +1080,10 @@ Tcl_UtfNcmp(cs, ct, numChars) */ int -Tcl_UtfNcasecmp(cs, ct, numChars) - CONST char *cs; /* UTF string to compare to ct. */ - CONST char *ct; /* UTF string cs is compared to. */ - unsigned long numChars; /* Number of UTF chars to compare. */ +Tcl_UtfNcasecmp( + CONST char *cs, /* UTF string to compare to ct. */ + CONST char *ct, /* UTF string cs is compared to. */ + unsigned long numChars) /* Number of UTF chars to compare. */ { Tcl_UniChar ch1, ch2; while (numChars-- > 0) { @@ -1118,8 +1122,8 @@ Tcl_UtfNcasecmp(cs, ct, numChars) */ Tcl_UniChar -Tcl_UniCharToUpper(ch) - int ch; /* Unicode character to convert. */ +Tcl_UniCharToUpper( + int ch) /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); @@ -1147,8 +1151,8 @@ Tcl_UniCharToUpper(ch) */ Tcl_UniChar -Tcl_UniCharToLower(ch) - int ch; /* Unicode character to convert. */ +Tcl_UniCharToLower( + int ch) /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); @@ -1176,8 +1180,8 @@ Tcl_UniCharToLower(ch) */ Tcl_UniChar -Tcl_UniCharToTitle(ch) - int ch; /* Unicode character to convert. */ +Tcl_UniCharToTitle( + int ch) /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); int mode = GetCaseType(info); @@ -1200,7 +1204,7 @@ Tcl_UniCharToTitle(ch) * * Tcl_UniCharLen -- * - * Find the length of a UniChar string. The str input must be null + * Find the length of a UniChar string. The str input must be null * terminated. * * Results: @@ -1213,11 +1217,11 @@ Tcl_UniCharToTitle(ch) */ int -Tcl_UniCharLen(uniStr) - CONST Tcl_UniChar *uniStr; /* Unicode string to find length of. */ +Tcl_UniCharLen( + CONST Tcl_UniChar *uniStr) /* Unicode string to find length of. */ { int len = 0; - + while (*uniStr != '\0') { len++; uniStr++; @@ -1243,10 +1247,10 @@ Tcl_UniCharLen(uniStr) */ int -Tcl_UniCharNcmp(ucs, uct, numChars) - CONST Tcl_UniChar *ucs; /* Unicode string to compare to uct. */ - CONST Tcl_UniChar *uct; /* Unicode string ucs is compared to. */ - unsigned long numChars; /* Number of unichars to compare. */ +Tcl_UniCharNcmp( + CONST Tcl_UniChar *ucs, /* Unicode string to compare to uct. */ + CONST Tcl_UniChar *uct, /* Unicode string ucs is compared to. */ + unsigned long numChars) /* Number of unichars to compare. */ { #ifdef WORDS_BIGENDIAN /* @@ -1275,7 +1279,7 @@ Tcl_UniCharNcmp(ucs, uct, numChars) * Tcl_UniCharNcasecmp -- * * Compare at most numChars unichars of string ucs to string uct case - * insensitive. Both ucs and uct are assumed to be at least numChars + * insensitive. Both ucs and uct are assumed to be at least numChars * unichars long. * * Results: @@ -1288,15 +1292,16 @@ Tcl_UniCharNcmp(ucs, uct, numChars) */ int -Tcl_UniCharNcasecmp(ucs, uct, numChars) - CONST Tcl_UniChar *ucs; /* Unicode string to compare to uct. */ - CONST Tcl_UniChar *uct; /* Unicode string ucs is compared to. */ - unsigned long numChars; /* Number of unichars to compare. */ +Tcl_UniCharNcasecmp( + CONST Tcl_UniChar *ucs, /* Unicode string to compare to uct. */ + CONST Tcl_UniChar *uct, /* Unicode string ucs is compared to. */ + unsigned long numChars) /* Number of unichars to compare. */ { for ( ; numChars != 0; numChars--, ucs++, uct++) { if (*ucs != *uct) { Tcl_UniChar lcs = Tcl_UniCharToLower(*ucs); Tcl_UniChar lct = Tcl_UniCharToLower(*uct); + if (lcs != lct) { return (lcs - lct); } @@ -1322,8 +1327,8 @@ Tcl_UniCharNcasecmp(ucs, uct, numChars) */ int -Tcl_UniCharIsAlnum(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsAlnum( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); @@ -1347,8 +1352,8 @@ Tcl_UniCharIsAlnum(ch) */ int -Tcl_UniCharIsAlpha(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsAlpha( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); return ((ALPHA_BITS >> category) & 1); @@ -1371,8 +1376,8 @@ Tcl_UniCharIsAlpha(ch) */ int -Tcl_UniCharIsControl(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsControl( + int ch) /* Unicode character to test. */ { return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == CONTROL); } @@ -1394,11 +1399,10 @@ Tcl_UniCharIsControl(ch) */ int -Tcl_UniCharIsDigit(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsDigit( + int ch) /* Unicode character to test. */ { - return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) - == DECIMAL_DIGIT_NUMBER); + return (GetUniCharInfo(ch)&UNICODE_CATEGORY_MASK) == DECIMAL_DIGIT_NUMBER; } /* @@ -1418,8 +1422,8 @@ Tcl_UniCharIsDigit(ch) */ int -Tcl_UniCharIsGraph(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsGraph( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); return (((PRINT_BITS >> category) & 1) && ((unsigned char) ch != ' ')); @@ -1442,8 +1446,8 @@ Tcl_UniCharIsGraph(ch) */ int -Tcl_UniCharIsLower(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsLower( + int ch) /* Unicode character to test. */ { return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == LOWERCASE_LETTER); } @@ -1465,8 +1469,8 @@ Tcl_UniCharIsLower(ch) */ int -Tcl_UniCharIsPrint(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsPrint( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); return ((PRINT_BITS >> category) & 1); @@ -1489,8 +1493,8 @@ Tcl_UniCharIsPrint(ch) */ int -Tcl_UniCharIsPunct(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsPunct( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); return ((PUNCT_BITS >> category) & 1); @@ -1513,8 +1517,8 @@ Tcl_UniCharIsPunct(ch) */ int -Tcl_UniCharIsSpace(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsSpace( + int ch) /* Unicode character to test. */ { register int category; @@ -1548,8 +1552,8 @@ Tcl_UniCharIsSpace(ch) */ int -Tcl_UniCharIsUpper(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsUpper( + int ch) /* Unicode character to test. */ { return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == UPPERCASE_LETTER); } @@ -1571,8 +1575,8 @@ Tcl_UniCharIsUpper(ch) */ int -Tcl_UniCharIsWordChar(ch) - int ch; /* Unicode character to test. */ +Tcl_UniCharIsWordChar( + int ch) /* Unicode character to test. */ { register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK); @@ -1603,24 +1607,24 @@ Tcl_UniCharIsWordChar(ch) */ int -Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase) - CONST Tcl_UniChar *uniStr; /* Unicode String. */ - CONST Tcl_UniChar *uniPattern; +Tcl_UniCharCaseMatch( + CONST Tcl_UniChar *uniStr, /* Unicode String. */ + CONST Tcl_UniChar *uniPattern, /* Pattern, which may contain special * characters. */ - int nocase; /* 0 for case sensitive, 1 for insensitive */ + int nocase) /* 0 for case sensitive, 1 for insensitive */ { Tcl_UniChar ch1, p; - + while (1) { p = *uniPattern; - + /* * See if we're at the end of both the pattern and the string. If so, * we succeeded. If we're at the end of the pattern but not at the end * of the string, we failed. */ - + if (p == 0) { return (*uniStr == 0); } @@ -1635,7 +1639,7 @@ Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase) * recursively for each postfix of string, until either we match or we * reach the end of the string. */ - + if (p == '*') { /* * Skip all successive *'s in the pattern @@ -1696,7 +1700,7 @@ Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase) * list of characters that are acceptable, or by a range (two * characters separated by "-"). */ - + if (p == '[') { Tcl_UniChar startChar, endChar; @@ -1752,8 +1756,8 @@ Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase) } /* - * There's no special character. Just make sure that the next bytes - * of each string match. + * There's no special character. Just make sure that the next bytes of + * each string match. */ if (nocase) { @@ -1791,13 +1795,13 @@ Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase) */ int -TclUniCharMatch(string, strLen, pattern, ptnLen, nocase) - CONST Tcl_UniChar *string; /* Unicode String. */ - int strLen; /* length of String */ - CONST Tcl_UniChar *pattern; /* Pattern, which may contain special +TclUniCharMatch( + CONST Tcl_UniChar *string, /* Unicode String. */ + int strLen, /* Length of String */ + CONST Tcl_UniChar *pattern, /* Pattern, which may contain special * characters. */ - int ptnLen; /* length of Pattern */ - int nocase; /* 0 for case sensitive, 1 for insensitive */ + int ptnLen, /* Length of Pattern */ + int nocase) /* 0 for case sensitive, 1 for insensitive */ { CONST Tcl_UniChar *stringEnd, *patternEnd; Tcl_UniChar p; @@ -1827,7 +1831,7 @@ TclUniCharMatch(string, strLen, pattern, ptnLen, nocase) * recursively for each postfix of string, until either we match or we * reach the end of the string. */ - + if (p == '*') { /* * Skip all successive *'s in the pattern. @@ -1889,7 +1893,7 @@ TclUniCharMatch(string, strLen, pattern, ptnLen, nocase) * list of characters that are acceptable, or by a range (two * characters separated by "-"). */ - + if (p == '[') { Tcl_UniChar ch1, startChar, endChar; |