diff options
Diffstat (limited to 'generic/tclTrace.c')
| -rw-r--r-- | generic/tclTrace.c | 2619 |
1 files changed, 1332 insertions, 1287 deletions
diff --git a/generic/tclTrace.c b/generic/tclTrace.c index c3aaa82..9d7ab86 100644 --- a/generic/tclTrace.c +++ b/generic/tclTrace.c @@ -1,4 +1,4 @@ -/* +/* * tclTrace.c -- * * This file contains code to handle most trace management. @@ -8,10 +8,10 @@ * Copyright (c) 1998-2000 Scriptics Corporation. * Copyright (c) 2002 ActiveState Corporation. * - * 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: tclTrace.c,v 1.25 2005/06/21 18:33:05 dgp Exp $ + * RCS: @(#) $Id: tclTrace.c,v 1.26 2005/07/23 00:04:31 dkf Exp $ */ #include "tclInt.h" @@ -21,14 +21,14 @@ */ typedef struct { - int flags; /* Operations for which Tcl command is - * to be invoked. */ + int flags; /* Operations for which Tcl command is to be + * invoked. */ size_t length; /* Number of non-NULL chars. in command. */ - char command[4]; /* Space for Tcl command to invoke. Actual - * size will be as large as necessary to - * hold command. This field must be the - * last in the structure, so that it can - * be larger than 4 bytes. */ + char command[4]; /* Space for Tcl command to invoke. Actual + * size will be as large as necessary to hold + * command. This field must be the last in the + * structure, so that it can be larger than 4 + * bytes. */ } TraceVarInfo; /* @@ -36,57 +36,58 @@ typedef struct { */ typedef struct { - int flags; /* Operations for which Tcl command is - * to be invoked. */ + int flags; /* Operations for which Tcl command is to be + * invoked. */ size_t length; /* Number of non-NULL chars. in command. */ - Tcl_Trace stepTrace; /* Used for execution traces, when tracing - * inside the given command */ - int startLevel; /* Used for bookkeeping with step execution - * traces, store the level at which the step - * trace was invoked */ - char *startCmd; /* Used for bookkeeping with step execution - * traces, store the command name which invoked - * step trace */ - int curFlags; /* Trace flags for the current command */ - int curCode; /* Return code for the current command */ - int refCount; /* Used to ensure this structure is - * not deleted too early. Keeps track - * of how many pieces of code have - * a pointer to this structure. */ - char command[4]; /* Space for Tcl command to invoke. Actual - * size will be as large as necessary to - * hold command. This field must be the - * last in the structure, so that it can - * be larger than 4 bytes. */ + Tcl_Trace stepTrace; /* Used for execution traces, when tracing + * inside the given command */ + int startLevel; /* Used for bookkeeping with step execution + * traces, store the level at which the step + * trace was invoked */ + char *startCmd; /* Used for bookkeeping with step execution + * traces, store the command name which + * invoked step trace */ + int curFlags; /* Trace flags for the current command */ + int curCode; /* Return code for the current command */ + int refCount; /* Used to ensure this structure is not + * deleted too early. Keeps track of how many + * pieces of code have a pointer to this + * structure. */ + char command[4]; /* Space for Tcl command to invoke. Actual + * size will be as large as necessary to hold + * command. This field must be the last in the + * structure, so that it can be larger than 4 + * bytes. */ } TraceCommandInfo; -/* - * Used by command execution traces. Note that we assume in the code - * that TCL_TRACE_ENTER_DURING_EXEC == 4 * TCL_TRACE_ENTER_EXEC and - * that TCL_TRACE_LEAVE_DURING_EXEC == 4 * TCL_TRACE_LEAVE_EXEC. - * +/* + * Used by command execution traces. Note that we assume in the code that + * TCL_TRACE_ENTER_DURING_EXEC == 4 * TCL_TRACE_ENTER_EXEC and that + * TCL_TRACE_LEAVE_DURING_EXEC == 4 * TCL_TRACE_LEAVE_EXEC. + * * TCL_TRACE_ENTER_DURING_EXEC - Trace each command inside the command - * currently being traced, before execution. + * currently being traced, before execution. * TCL_TRACE_LEAVE_DURING_EXEC - Trace each command inside the command - * currently being traced, after execution. - * TCL_TRACE_ANY_EXEC - OR'd combination of all EXEC flags. - * TCL_TRACE_EXEC_IN_PROGRESS - The callback procedure on this trace - * is currently executing. Therefore we - * don't let further traces execute. - * TCL_TRACE_EXEC_DIRECT - This execution trace is triggered directly - * by the command being traced, not because - * of an internal trace. - * The flags 'TCL_TRACE_DESTROYED' and 'TCL_INTERP_DESTROYED' may also - * be used in command execution traces. + * currently being traced, after execution. + * TCL_TRACE_ANY_EXEC - OR'd combination of all EXEC flags. + * TCL_TRACE_EXEC_IN_PROGRESS - The callback function on this trace is + * currently executing. Therefore we don't let + * further traces execute. + * TCL_TRACE_EXEC_DIRECT - This execution trace is triggered directly + * by the command being traced, not because of + * an internal trace. + * The flags 'TCL_TRACE_DESTROYED' and 'TCL_INTERP_DESTROYED' may also be used + * in command execution traces. */ + #define TCL_TRACE_ENTER_DURING_EXEC 4 #define TCL_TRACE_LEAVE_DURING_EXEC 8 -#define TCL_TRACE_ANY_EXEC 15 -#define TCL_TRACE_EXEC_IN_PROGRESS 0x10 -#define TCL_TRACE_EXEC_DIRECT 0x20 +#define TCL_TRACE_ANY_EXEC 15 +#define TCL_TRACE_EXEC_IN_PROGRESS 0x10 +#define TCL_TRACE_EXEC_DIRECT 0x20 /* - * Forward declarations for procedures defined in this file: + * Forward declarations for functions defined in this file: */ typedef int (Tcl_TraceTypeObjCmd) _ANSI_ARGS_((Tcl_Interp *interp, @@ -96,13 +97,13 @@ Tcl_TraceTypeObjCmd TclTraceVariableObjCmd; Tcl_TraceTypeObjCmd TclTraceCommandObjCmd; Tcl_TraceTypeObjCmd TclTraceExecutionObjCmd; -/* - * Each subcommand has a number of 'types' to which it can apply. - * Currently 'execution', 'command' and 'variable' are the only - * types supported. These three arrays MUST be kept in sync! - * In the future we may provide an API to add to the list of - * supported trace types. +/* + * Each subcommand has a number of 'types' to which it can apply. Currently + * 'execution', 'command' and 'variable' are the only types supported. These + * three arrays MUST be kept in sync! In the future we may provide an API to + * add to the list of supported trace types. */ + static CONST char *traceTypeOptions[] = { "execution", "command", "variable", (char*) NULL }; @@ -113,27 +114,26 @@ static Tcl_TraceTypeObjCmd* traceSubCmds[] = { }; /* - * Declarations for local procedures to this file: + * Declarations for local functions to this file: */ -static int CallTraceProcedure _ANSI_ARGS_((Tcl_Interp *interp, - Trace *tracePtr, Command *cmdPtr, - CONST char *command, int numChars, - int objc, Tcl_Obj *CONST objv[])); + +static int CallTraceFunction _ANSI_ARGS_((Tcl_Interp *interp, + Trace *tracePtr, Command *cmdPtr, + CONST char *command, int numChars, + int objc, Tcl_Obj *CONST objv[])); static char * TraceVarProc _ANSI_ARGS_((ClientData clientData, - Tcl_Interp *interp, CONST char *name1, - CONST char *name2, int flags)); + Tcl_Interp *interp, CONST char *name1, + CONST char *name2, int flags)); static void TraceCommandProc _ANSI_ARGS_((ClientData clientData, Tcl_Interp *interp, CONST char *oldName, - CONST char *newName, int flags)); + CONST char *newName, int flags)); static Tcl_CmdObjTraceProc TraceExecutionProc; -static int StringTraceProc _ANSI_ARGS_((ClientData clientData, - Tcl_Interp* interp, - int level, - CONST char* command, - Tcl_Command commandInfo, - int objc, - Tcl_Obj *CONST objv[])); -static void StringTraceDeleteProc _ANSI_ARGS_((ClientData clientData)); +static int StringTraceProc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp* interp, int level, + CONST char* command, Tcl_Command commandInfo, + int objc, Tcl_Obj *CONST objv[])); +static void StringTraceDeleteProc _ANSI_ARGS_(( + ClientData clientData)); static void DisposeTraceResult _ANSI_ARGS_((int flags, char *result)); @@ -144,7 +144,7 @@ static void DisposeTraceResult _ANSI_ARGS_((int flags, typedef struct StringTraceData { ClientData clientData; /* Client data from Tcl_CreateTrace */ - Tcl_CmdTraceProc* proc; /* Trace procedure from Tcl_CreateTrace */ + Tcl_CmdTraceProc* proc; /* Trace function from Tcl_CreateTrace */ } StringTraceData; /* @@ -152,13 +152,11 @@ typedef struct StringTraceData { * * Tcl_TraceObjCmd -- * - * This procedure is invoked to process the "trace" Tcl command. - * See the user documentation for details on what it does. - * - * Standard syntax as of Tcl 8.4 is - * - * trace {add|info|remove} {command|variable} name ops cmd + * This function is invoked to process the "trace" Tcl command. See the + * user documentation for details on what it does. * + * Standard syntax as of Tcl 8.4 is: + * trace {add|info|remove} {command|variable} name ops cmd * * Results: * A standard Tcl result. @@ -180,15 +178,15 @@ Tcl_TraceObjCmd(dummy, interp, objc, objv) char *name, *flagOps, *p; /* Main sub commands to 'trace' */ static CONST char *traceOptions[] = { - "add", "info", "remove", + "add", "info", "remove", #ifndef TCL_REMOVE_OBSOLETE_TRACES - "variable", "vdelete", "vinfo", + "variable", "vdelete", "vinfo", #endif (char *) NULL }; /* 'OLD' options are pre-Tcl-8.4 style */ enum traceOptions { - TRACE_ADD, TRACE_INFO, TRACE_REMOVE, + TRACE_ADD, TRACE_INFO, TRACE_REMOVE, #ifndef TCL_REMOVE_OBSOLETE_TRACES TRACE_OLD_VARIABLE, TRACE_OLD_VDELETE, TRACE_OLD_VINFO #endif @@ -204,174 +202,177 @@ Tcl_TraceObjCmd(dummy, interp, objc, objv) return TCL_ERROR; } switch ((enum traceOptions) optionIndex) { - case TRACE_ADD: - case TRACE_REMOVE: { - /* - * All sub commands of trace add/remove must take at least - * one more argument. Beyond that we let the subcommand itself - * control the argument structure. - */ - int typeIndex; - if (objc < 3) { - Tcl_WrongNumArgs(interp, 2, objv, "type ?arg arg ...?"); - return TCL_ERROR; - } - if (Tcl_GetIndexFromObj(interp, objv[2], traceTypeOptions, - "option", 0, &typeIndex) != TCL_OK) { - return TCL_ERROR; - } - return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv); + case TRACE_ADD: + case TRACE_REMOVE: { + /* + * All sub commands of trace add/remove must take at least one more + * argument. Beyond that we let the subcommand itself control the + * argument structure. + */ + + int typeIndex; + + if (objc < 3) { + Tcl_WrongNumArgs(interp, 2, objv, "type ?arg arg ...?"); + return TCL_ERROR; } - case TRACE_INFO: { - /* - * All sub commands of trace info must take exactly two - * more arguments which name the type of thing being - * traced and the name of the thing being traced. + if (Tcl_GetIndexFromObj(interp, objv[2], traceTypeOptions, "option", + 0, &typeIndex) != TCL_OK) { + return TCL_ERROR; + } + return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv); + } + case TRACE_INFO: { + /* + * All sub commands of trace info must take exactly two more arguments + * which name the type of thing being traced and the name of the thing + * being traced. + */ + + int typeIndex; + if (objc < 3) { + /* + * Delegate other complaints to the type-specific code which can + * give a better error message. */ - int typeIndex; - if (objc < 3) { - /* - * Delegate other complaints to the type-specific code - * which can give a better error message. - */ - Tcl_WrongNumArgs(interp, 2, objv, "type name"); - return TCL_ERROR; - } - if (Tcl_GetIndexFromObj(interp, objv[2], traceTypeOptions, - "option", 0, &typeIndex) != TCL_OK) { - return TCL_ERROR; - } - return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv); - break; + + Tcl_WrongNumArgs(interp, 2, objv, "type name"); + return TCL_ERROR; + } + if (Tcl_GetIndexFromObj(interp, objv[2], traceTypeOptions, "option", + 0, &typeIndex) != TCL_OK) { + return TCL_ERROR; } + return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv); + break; + } #ifndef TCL_REMOVE_OBSOLETE_TRACES - case TRACE_OLD_VARIABLE: - case TRACE_OLD_VDELETE: { - Tcl_Obj *copyObjv[6]; - Tcl_Obj *opsList; - int code, numFlags; - - if (objc != 5) { - Tcl_WrongNumArgs(interp, 2, objv, "name ops command"); - return TCL_ERROR; - } + case TRACE_OLD_VARIABLE: + case TRACE_OLD_VDELETE: { + Tcl_Obj *copyObjv[6]; + Tcl_Obj *opsList; + int code, numFlags; + + if (objc != 5) { + Tcl_WrongNumArgs(interp, 2, objv, "name ops command"); + return TCL_ERROR; + } - opsList = Tcl_NewObj(); - Tcl_IncrRefCount(opsList); - flagOps = Tcl_GetStringFromObj(objv[3], &numFlags); - if (numFlags == 0) { + opsList = Tcl_NewObj(); + Tcl_IncrRefCount(opsList); + flagOps = Tcl_GetStringFromObj(objv[3], &numFlags); + if (numFlags == 0) { + Tcl_DecrRefCount(opsList); + goto badVarOps; + } + for (p = flagOps; *p != 0; p++) { + if (*p == 'r') { + Tcl_ListObjAppendElement(NULL, opsList, + Tcl_NewStringObj("read", -1)); + } else if (*p == 'w') { + Tcl_ListObjAppendElement(NULL, opsList, + Tcl_NewStringObj("write", -1)); + } else if (*p == 'u') { + Tcl_ListObjAppendElement(NULL, opsList, + Tcl_NewStringObj("unset", -1)); + } else if (*p == 'a') { + Tcl_ListObjAppendElement(NULL, opsList, + Tcl_NewStringObj("array", -1)); + } else { Tcl_DecrRefCount(opsList); goto badVarOps; } - for (p = flagOps; *p != 0; p++) { - if (*p == 'r') { - Tcl_ListObjAppendElement(NULL, opsList, - Tcl_NewStringObj("read", -1)); - } else if (*p == 'w') { - Tcl_ListObjAppendElement(NULL, opsList, - Tcl_NewStringObj("write", -1)); - } else if (*p == 'u') { - Tcl_ListObjAppendElement(NULL, opsList, - Tcl_NewStringObj("unset", -1)); - } else if (*p == 'a') { - Tcl_ListObjAppendElement(NULL, opsList, - Tcl_NewStringObj("array", -1)); - } else { - Tcl_DecrRefCount(opsList); - goto badVarOps; - } + } + copyObjv[0] = NULL; + memcpy(copyObjv+1, objv, objc*sizeof(Tcl_Obj *)); + copyObjv[4] = opsList; + if (optionIndex == TRACE_OLD_VARIABLE) { + code = (traceSubCmds[2])(interp,TRACE_ADD,objc+1,copyObjv); + } else { + code = (traceSubCmds[2])(interp,TRACE_REMOVE,objc+1,copyObjv); + } + Tcl_DecrRefCount(opsList); + return code; + } + case TRACE_OLD_VINFO: { + ClientData clientData; + char ops[5]; + Tcl_Obj *resultListPtr, *pairObjPtr, *elemObjPtr; + + if (objc != 3) { + Tcl_WrongNumArgs(interp, 2, objv, "name"); + return TCL_ERROR; + } + resultListPtr = Tcl_NewObj(); + clientData = 0; + name = Tcl_GetString(objv[2]); + while ((clientData = Tcl_VarTraceInfo(interp, name, 0, + TraceVarProc, clientData)) != 0) { + + TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData; + + pairObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + p = ops; + if (tvarPtr->flags & TCL_TRACE_READS) { + *p = 'r'; + p++; } - copyObjv[0] = NULL; - memcpy(copyObjv+1, objv, objc*sizeof(Tcl_Obj *)); - copyObjv[4] = opsList; - if (optionIndex == TRACE_OLD_VARIABLE) { - code = (traceSubCmds[2])(interp,TRACE_ADD,objc+1,copyObjv); - } else { - code = (traceSubCmds[2])(interp,TRACE_REMOVE,objc+1,copyObjv); + if (tvarPtr->flags & TCL_TRACE_WRITES) { + *p = 'w'; + p++; } - Tcl_DecrRefCount(opsList); - return code; - } - case TRACE_OLD_VINFO: { - ClientData clientData; - char ops[5]; - Tcl_Obj *resultListPtr, *pairObjPtr, *elemObjPtr; - - if (objc != 3) { - Tcl_WrongNumArgs(interp, 2, objv, "name"); - return TCL_ERROR; + if (tvarPtr->flags & TCL_TRACE_UNSETS) { + *p = 'u'; + p++; } - resultListPtr = Tcl_NewObj(); - clientData = 0; - name = Tcl_GetString(objv[2]); - while ((clientData = Tcl_VarTraceInfo(interp, name, 0, - TraceVarProc, clientData)) != 0) { - - TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData; - - pairObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - p = ops; - if (tvarPtr->flags & TCL_TRACE_READS) { - *p = 'r'; - p++; - } - if (tvarPtr->flags & TCL_TRACE_WRITES) { - *p = 'w'; - p++; - } - if (tvarPtr->flags & TCL_TRACE_UNSETS) { - *p = 'u'; - p++; - } - if (tvarPtr->flags & TCL_TRACE_ARRAY) { - *p = 'a'; - p++; - } - *p = '\0'; + if (tvarPtr->flags & TCL_TRACE_ARRAY) { + *p = 'a'; + p++; + } + *p = '\0'; - /* - * Build a pair (2-item list) with the ops string as - * the first obj element and the tvarPtr->command string - * as the second obj element. Append the pair (as an - * element) to the end of the result object list. - */ + /* + * Build a pair (2-item list) with the ops string as the first obj + * element and the tvarPtr->command string as the second obj + * element. Append the pair (as an element) to the end of the + * result object list. + */ - elemObjPtr = Tcl_NewStringObj(ops, -1); - Tcl_ListObjAppendElement(NULL, pairObjPtr, elemObjPtr); - elemObjPtr = Tcl_NewStringObj(tvarPtr->command, -1); - Tcl_ListObjAppendElement(NULL, pairObjPtr, elemObjPtr); - Tcl_ListObjAppendElement(interp, resultListPtr, pairObjPtr); - } - Tcl_SetObjResult(interp, resultListPtr); - break; + elemObjPtr = Tcl_NewStringObj(ops, -1); + Tcl_ListObjAppendElement(NULL, pairObjPtr, elemObjPtr); + elemObjPtr = Tcl_NewStringObj(tvarPtr->command, -1); + Tcl_ListObjAppendElement(NULL, pairObjPtr, elemObjPtr); + Tcl_ListObjAppendElement(interp, resultListPtr, pairObjPtr); } + Tcl_SetObjResult(interp, resultListPtr); + break; + } #endif /* TCL_REMOVE_OBSOLETE_TRACES */ } return TCL_OK; - badVarOps: + badVarOps: Tcl_AppendResult(interp, "bad operations \"", flagOps, "\": should be one or more of rwua", (char *) NULL); return TCL_ERROR; } - /* *---------------------------------------------------------------------- * * TclTraceExecutionObjCmd -- * - * Helper function for Tcl_TraceObjCmd; implements the - * [trace {add|remove|info} execution ...] subcommands. - * See the user documentation for details on what these do. + * Helper function for Tcl_TraceObjCmd; implements the [trace + * {add|remove|info} execution ...] subcommands. See the user + * documentation for details on what these do. * * Results: * Standard Tcl result. * * Side effects: - * Depends on the operation (add, remove, or info) being performed; - * may add or remove command traces on a command. + * Depends on the operation (add, remove, or info) being performed; may + * add or remove command traces on a command. * *---------------------------------------------------------------------- */ @@ -386,233 +387,239 @@ TclTraceExecutionObjCmd(interp, optionIndex, objc, objv) int commandLength, index; char *name, *command; size_t length; - enum traceOptions { TRACE_ADD, TRACE_INFO, TRACE_REMOVE }; - static CONST char *opStrings[] = { "enter", "leave", - "enterstep", "leavestep", (char *) NULL }; - enum operations { TRACE_EXEC_ENTER, TRACE_EXEC_LEAVE, - TRACE_EXEC_ENTER_STEP, TRACE_EXEC_LEAVE_STEP }; - + enum traceOptions { + TRACE_ADD, TRACE_INFO, TRACE_REMOVE + }; + static CONST char *opStrings[] = { + "enter", "leave", "enterstep", "leavestep", (char *) NULL + }; + enum operations { + TRACE_EXEC_ENTER, TRACE_EXEC_LEAVE, + TRACE_EXEC_ENTER_STEP, TRACE_EXEC_LEAVE_STEP + }; + switch ((enum traceOptions) optionIndex) { - case TRACE_ADD: - case TRACE_REMOVE: { - int flags = 0; - int i, listLen, result; - Tcl_Obj **elemPtrs; - if (objc != 6) { - Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); - return TCL_ERROR; - } - /* - * Make sure the ops argument is a list object; get its length and - * a pointer to its array of element pointers. - */ + case TRACE_ADD: + case TRACE_REMOVE: { + int flags = 0; + int i, listLen, result; + Tcl_Obj **elemPtrs; + + if (objc != 6) { + Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); + return TCL_ERROR; + } - result = Tcl_ListObjGetElements(interp, objv[4], &listLen, - &elemPtrs); - if (result != TCL_OK) { - return result; - } - if (listLen == 0) { - Tcl_SetResult(interp, "bad operation list \"\": must be " - "one or more of enter, leave, enterstep, or leavestep", - TCL_STATIC); + /* + * Make sure the ops argument is a list object; get its length and a + * pointer to its array of element pointers. + */ + + result = Tcl_ListObjGetElements(interp, objv[4], &listLen, &elemPtrs); + if (result != TCL_OK) { + return result; + } + if (listLen == 0) { + Tcl_SetResult(interp, "bad operation list \"\": must be " + "one or more of enter, leave, enterstep, or leavestep", + TCL_STATIC); + return TCL_ERROR; + } + for (i = 0; i < listLen; i++) { + if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, + "operation", TCL_EXACT, &index) != TCL_OK) { return TCL_ERROR; } - for (i = 0; i < listLen; i++) { - if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, - "operation", TCL_EXACT, &index) != TCL_OK) { - return TCL_ERROR; - } - switch ((enum operations) index) { - case TRACE_EXEC_ENTER: - flags |= TCL_TRACE_ENTER_EXEC; - break; - case TRACE_EXEC_LEAVE: - flags |= TCL_TRACE_LEAVE_EXEC; - break; - case TRACE_EXEC_ENTER_STEP: - flags |= TCL_TRACE_ENTER_DURING_EXEC; - break; - case TRACE_EXEC_LEAVE_STEP: - flags |= TCL_TRACE_LEAVE_DURING_EXEC; - break; - } - } - command = Tcl_GetStringFromObj(objv[5], &commandLength); - length = (size_t) commandLength; - if ((enum traceOptions) optionIndex == TRACE_ADD) { - TraceCommandInfo *tcmdPtr; - tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned) - (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command) - + length + 1)); - tcmdPtr->flags = flags; - tcmdPtr->stepTrace = NULL; - tcmdPtr->startLevel = 0; - tcmdPtr->startCmd = NULL; - tcmdPtr->length = length; - tcmdPtr->refCount = 1; - flags |= TCL_TRACE_DELETE; - if (flags & (TCL_TRACE_ENTER_DURING_EXEC | - TCL_TRACE_LEAVE_DURING_EXEC)) { - flags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC); - } - strcpy(tcmdPtr->command, command); - name = Tcl_GetString(objv[3]); - if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc, - (ClientData) tcmdPtr) != TCL_OK) { - ckfree((char *) tcmdPtr); - return TCL_ERROR; - } - } else { - /* - * Search through all of our traces on this command to - * see if there's one with the given command. If so, then - * delete the first one that matches. - */ - - TraceCommandInfo *tcmdPtr; - ClientData clientData = NULL; - name = Tcl_GetString(objv[3]); - - /* First ensure the name given is valid */ - if (Tcl_FindCommand(interp, name, NULL, - TCL_LEAVE_ERR_MSG) == NULL) { - return TCL_ERROR; - } - - while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, - TraceCommandProc, clientData)) != NULL) { - tcmdPtr = (TraceCommandInfo *) clientData; - /* - * In checking the 'flags' field we must remove any - * extraneous flags which may have been temporarily - * added by various pieces of the trace mechanism. - */ - if ((tcmdPtr->length == length) - && ((tcmdPtr->flags & (TCL_TRACE_ANY_EXEC | - TCL_TRACE_RENAME | - TCL_TRACE_DELETE)) == flags) - && (strncmp(command, tcmdPtr->command, - (size_t) length) == 0)) { - flags |= TCL_TRACE_DELETE; - if (flags & (TCL_TRACE_ENTER_DURING_EXEC | - TCL_TRACE_LEAVE_DURING_EXEC)) { - flags |= (TCL_TRACE_ENTER_EXEC | - TCL_TRACE_LEAVE_EXEC); - } - Tcl_UntraceCommand(interp, name, - flags, TraceCommandProc, clientData); - if (tcmdPtr->stepTrace != NULL) { - /* - * We need to remove the interpreter-wide trace - * which we created to allow 'step' traces. - */ - Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); - tcmdPtr->stepTrace = NULL; - if (tcmdPtr->startCmd != NULL) { - ckfree((char *)tcmdPtr->startCmd); - } - } - if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) { - /* Postpone deletion */ - tcmdPtr->flags = 0; - } - if ((--tcmdPtr->refCount) <= 0) { - ckfree((char*)tcmdPtr); - } - break; - } - } + switch ((enum operations) index) { + case TRACE_EXEC_ENTER: + flags |= TCL_TRACE_ENTER_EXEC; + break; + case TRACE_EXEC_LEAVE: + flags |= TCL_TRACE_LEAVE_EXEC; + break; + case TRACE_EXEC_ENTER_STEP: + flags |= TCL_TRACE_ENTER_DURING_EXEC; + break; + case TRACE_EXEC_LEAVE_STEP: + flags |= TCL_TRACE_LEAVE_DURING_EXEC; + break; } - break; } - case TRACE_INFO: { - ClientData clientData; - Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; - if (objc != 4) { - Tcl_WrongNumArgs(interp, 3, objv, "name"); + command = Tcl_GetStringFromObj(objv[5], &commandLength); + length = (size_t) commandLength; + if ((enum traceOptions) optionIndex == TRACE_ADD) { + TraceCommandInfo *tcmdPtr; + + tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned) + (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command) + + length + 1)); + tcmdPtr->flags = flags; + tcmdPtr->stepTrace = NULL; + tcmdPtr->startLevel = 0; + tcmdPtr->startCmd = NULL; + tcmdPtr->length = length; + tcmdPtr->refCount = 1; + flags |= TCL_TRACE_DELETE; + if (flags & (TCL_TRACE_ENTER_DURING_EXEC | + TCL_TRACE_LEAVE_DURING_EXEC)) { + flags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC); + } + strcpy(tcmdPtr->command, command); + name = Tcl_GetString(objv[3]); + if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc, + (ClientData) tcmdPtr) != TCL_OK) { + ckfree((char *) tcmdPtr); return TCL_ERROR; } + } else { + /* + * Search through all of our traces on this command to see if + * there's one with the given command. If so, then delete the + * first one that matches. + */ - clientData = NULL; + TraceCommandInfo *tcmdPtr; + ClientData clientData = NULL; name = Tcl_GetString(objv[3]); - + /* First ensure the name given is valid */ - if (Tcl_FindCommand(interp, name, NULL, - TCL_LEAVE_ERR_MSG) == NULL) { + if (Tcl_FindCommand(interp, name, NULL, + TCL_LEAVE_ERR_MSG) == NULL) { return TCL_ERROR; } - - resultListPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, TraceCommandProc, clientData)) != NULL) { - int numOps = 0; - - TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData; + tcmdPtr = (TraceCommandInfo *) clientData; /* - * Build a list with the ops list as the first obj - * element and the tcmdPtr->command string as the - * second obj element. Append this list (as an - * element) to the end of the result object list. + * In checking the 'flags' field we must remove any extraneous + * flags which may have been temporarily added by various + * pieces of the trace mechanism. */ - elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - Tcl_IncrRefCount(elemObjPtr); - if (tcmdPtr->flags & TCL_TRACE_ENTER_EXEC) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("enter",5)); - } - if (tcmdPtr->flags & TCL_TRACE_LEAVE_EXEC) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("leave",5)); - } - if (tcmdPtr->flags & TCL_TRACE_ENTER_DURING_EXEC) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("enterstep",9)); - } - if (tcmdPtr->flags & TCL_TRACE_LEAVE_DURING_EXEC) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("leavestep",9)); - } - Tcl_ListObjLength(NULL, elemObjPtr, &numOps); - if (0 == numOps) { - Tcl_DecrRefCount(elemObjPtr); - continue; + if ((tcmdPtr->length == length) + && ((tcmdPtr->flags & (TCL_TRACE_ANY_EXEC | + TCL_TRACE_RENAME | TCL_TRACE_DELETE)) == flags) + && (strncmp(command, tcmdPtr->command, + (size_t) length) == 0)) { + flags |= TCL_TRACE_DELETE; + if (flags & (TCL_TRACE_ENTER_DURING_EXEC | + TCL_TRACE_LEAVE_DURING_EXEC)) { + flags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC); + } + Tcl_UntraceCommand(interp, name, flags, + TraceCommandProc, clientData); + if (tcmdPtr->stepTrace != NULL) { + /* + * We need to remove the interpreter-wide trace which + * we created to allow 'step' traces. + */ + + Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); + tcmdPtr->stepTrace = NULL; + if (tcmdPtr->startCmd != NULL) { + ckfree((char *)tcmdPtr->startCmd); + } + } + if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) { + /* Postpone deletion */ + tcmdPtr->flags = 0; + } + if ((--tcmdPtr->refCount) <= 0) { + ckfree((char*)tcmdPtr); + } + break; } - eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + } + } + break; + } + case TRACE_INFO: { + ClientData clientData; + Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; + + if (objc != 4) { + Tcl_WrongNumArgs(interp, 3, objv, "name"); + return TCL_ERROR; + } + + clientData = NULL; + name = Tcl_GetString(objv[3]); + + /* First ensure the name given is valid */ + if (Tcl_FindCommand(interp, name, NULL, TCL_LEAVE_ERR_MSG) == NULL) { + return TCL_ERROR; + } + + resultListPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, + TraceCommandProc, clientData)) != NULL) { + int numOps = 0; + + TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData; + + /* + * Build a list with the ops list as the first obj element and the + * tcmdPtr->command string as the second obj element. Append this + * list (as an element) to the end of the result object list. + */ + + elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_IncrRefCount(elemObjPtr); + if (tcmdPtr->flags & TCL_TRACE_ENTER_EXEC) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("enter",5)); + } + if (tcmdPtr->flags & TCL_TRACE_LEAVE_EXEC) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("leave",5)); + } + if (tcmdPtr->flags & TCL_TRACE_ENTER_DURING_EXEC) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("enterstep",9)); + } + if (tcmdPtr->flags & TCL_TRACE_LEAVE_DURING_EXEC) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("leavestep",9)); + } + Tcl_ListObjLength(NULL, elemObjPtr, &numOps); + if (0 == numOps) { Tcl_DecrRefCount(elemObjPtr); - elemObjPtr = NULL; - - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, - Tcl_NewStringObj(tcmdPtr->command, -1)); - Tcl_ListObjAppendElement(interp, resultListPtr, - eachTraceObjPtr); - } - Tcl_SetObjResult(interp, resultListPtr); - break; + continue; + } + eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + Tcl_DecrRefCount(elemObjPtr); + elemObjPtr = NULL; + + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, + Tcl_NewStringObj(tcmdPtr->command, -1)); + Tcl_ListObjAppendElement(interp, resultListPtr, + eachTraceObjPtr); } + Tcl_SetObjResult(interp, resultListPtr); + break; + } } return TCL_OK; } - /* *---------------------------------------------------------------------- * * TclTraceCommandObjCmd -- * - * Helper function for Tcl_TraceObjCmd; implements the - * [trace {add|info|remove} command ...] subcommands. - * See the user documentation for details on what these do. + * Helper function for Tcl_TraceObjCmd; implements the [trace + * {add|info|remove} command ...] subcommands. See the user documentation + * for details on what these do. * * Results: * Standard Tcl result. * * Side effects: - * Depends on the operation (add, remove, or info) being performed; - * may add or remove command traces on a command. + * Depends on the operation (add, remove, or info) being performed; may + * add or remove command traces on a command. * *---------------------------------------------------------------------- */ @@ -630,182 +637,182 @@ TclTraceCommandObjCmd(interp, optionIndex, objc, objv) enum traceOptions { TRACE_ADD, TRACE_INFO, TRACE_REMOVE }; static CONST char *opStrings[] = { "delete", "rename", (char *) NULL }; enum operations { TRACE_CMD_DELETE, TRACE_CMD_RENAME }; - + switch ((enum traceOptions) optionIndex) { - case TRACE_ADD: - case TRACE_REMOVE: { - int flags = 0; - int i, listLen, result; - Tcl_Obj **elemPtrs; - if (objc != 6) { - Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); - return TCL_ERROR; - } - /* - * Make sure the ops argument is a list object; get its length and - * a pointer to its array of element pointers. - */ + case TRACE_ADD: + case TRACE_REMOVE: { + int flags = 0; + int i, listLen, result; + Tcl_Obj **elemPtrs; + + if (objc != 6) { + Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); + return TCL_ERROR; + } - result = Tcl_ListObjGetElements(interp, objv[4], &listLen, - &elemPtrs); - if (result != TCL_OK) { - return result; - } - if (listLen == 0) { - Tcl_SetResult(interp, "bad operation list \"\": must be " - "one or more of delete or rename", TCL_STATIC); + /* + * Make sure the ops argument is a list object; get its length and a + * pointer to its array of element pointers. + */ + + result = Tcl_ListObjGetElements(interp, objv[4], &listLen, &elemPtrs); + if (result != TCL_OK) { + return result; + } + if (listLen == 0) { + Tcl_SetResult(interp, "bad operation list \"\": must be " + "one or more of delete or rename", TCL_STATIC); + return TCL_ERROR; + } + + for (i = 0; i < listLen; i++) { + if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, + "operation", TCL_EXACT, &index) != TCL_OK) { return TCL_ERROR; } - for (i = 0; i < listLen; i++) { - if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, - "operation", TCL_EXACT, &index) != TCL_OK) { - return TCL_ERROR; - } - switch ((enum operations) index) { - case TRACE_CMD_RENAME: - flags |= TCL_TRACE_RENAME; - break; - case TRACE_CMD_DELETE: - flags |= TCL_TRACE_DELETE; - break; - } - } - command = Tcl_GetStringFromObj(objv[5], &commandLength); - length = (size_t) commandLength; - if ((enum traceOptions) optionIndex == TRACE_ADD) { - TraceCommandInfo *tcmdPtr; - tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned) - (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command) - + length + 1)); - tcmdPtr->flags = flags; - tcmdPtr->stepTrace = NULL; - tcmdPtr->startLevel = 0; - tcmdPtr->startCmd = NULL; - tcmdPtr->length = length; - tcmdPtr->refCount = 1; + switch ((enum operations) index) { + case TRACE_CMD_RENAME: + flags |= TCL_TRACE_RENAME; + break; + case TRACE_CMD_DELETE: flags |= TCL_TRACE_DELETE; - strcpy(tcmdPtr->command, command); - name = Tcl_GetString(objv[3]); - if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc, - (ClientData) tcmdPtr) != TCL_OK) { - ckfree((char *) tcmdPtr); - return TCL_ERROR; - } - } else { - /* - * Search through all of our traces on this command to - * see if there's one with the given command. If so, then - * delete the first one that matches. - */ - - TraceCommandInfo *tcmdPtr; - ClientData clientData = NULL; - name = Tcl_GetString(objv[3]); - - /* First ensure the name given is valid */ - if (Tcl_FindCommand(interp, name, NULL, - TCL_LEAVE_ERR_MSG) == NULL) { - return TCL_ERROR; - } - - while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, - TraceCommandProc, clientData)) != NULL) { - tcmdPtr = (TraceCommandInfo *) clientData; - if ((tcmdPtr->length == length) - && (tcmdPtr->flags == flags) - && (strncmp(command, tcmdPtr->command, - (size_t) length) == 0)) { - Tcl_UntraceCommand(interp, name, - flags | TCL_TRACE_DELETE, - TraceCommandProc, clientData); - tcmdPtr->flags |= TCL_TRACE_DESTROYED; - if ((--tcmdPtr->refCount) <= 0) { - ckfree((char *) tcmdPtr); - } - break; - } - } + break; } - break; } - case TRACE_INFO: { - ClientData clientData; - Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; - if (objc != 4) { - Tcl_WrongNumArgs(interp, 3, objv, "name"); + + command = Tcl_GetStringFromObj(objv[5], &commandLength); + length = (size_t) commandLength; + if ((enum traceOptions) optionIndex == TRACE_ADD) { + TraceCommandInfo *tcmdPtr; + + tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned) + (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command) + + length + 1)); + tcmdPtr->flags = flags; + tcmdPtr->stepTrace = NULL; + tcmdPtr->startLevel = 0; + tcmdPtr->startCmd = NULL; + tcmdPtr->length = length; + tcmdPtr->refCount = 1; + flags |= TCL_TRACE_DELETE; + strcpy(tcmdPtr->command, command); + name = Tcl_GetString(objv[3]); + if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc, + (ClientData) tcmdPtr) != TCL_OK) { + ckfree((char *) tcmdPtr); return TCL_ERROR; } + } else { + /* + * Search through all of our traces on this command to see if + * there's one with the given command. If so, then delete the + * first one that matches. + */ - clientData = NULL; + TraceCommandInfo *tcmdPtr; + ClientData clientData = NULL; name = Tcl_GetString(objv[3]); - + /* First ensure the name given is valid */ - if (Tcl_FindCommand(interp, name, NULL, - TCL_LEAVE_ERR_MSG) == NULL) { + if (Tcl_FindCommand(interp, name, NULL, + TCL_LEAVE_ERR_MSG) == NULL) { return TCL_ERROR; } - - resultListPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, TraceCommandProc, clientData)) != NULL) { - int numOps = 0; + tcmdPtr = (TraceCommandInfo *) clientData; + if ((tcmdPtr->length == length) + && (tcmdPtr->flags == flags) + && (strncmp(command, tcmdPtr->command, + (size_t) length) == 0)) { + Tcl_UntraceCommand(interp, name, flags | TCL_TRACE_DELETE, + TraceCommandProc, clientData); + tcmdPtr->flags |= TCL_TRACE_DESTROYED; + if ((--tcmdPtr->refCount) <= 0) { + ckfree((char *) tcmdPtr); + } + break; + } + } + } + break; + } + case TRACE_INFO: { + ClientData clientData; + Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; - TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData; + if (objc != 4) { + Tcl_WrongNumArgs(interp, 3, objv, "name"); + return TCL_ERROR; + } - /* - * Build a list with the ops list as - * the first obj element and the tcmdPtr->command string - * as the second obj element. Append this list (as an - * element) to the end of the result object list. - */ + clientData = NULL; + name = Tcl_GetString(objv[3]); - elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - Tcl_IncrRefCount(elemObjPtr); - if (tcmdPtr->flags & TCL_TRACE_RENAME) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("rename",6)); - } - if (tcmdPtr->flags & TCL_TRACE_DELETE) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("delete",6)); - } - Tcl_ListObjLength(NULL, elemObjPtr, &numOps); - if (0 == numOps) { - Tcl_DecrRefCount(elemObjPtr); - continue; - } - eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); - Tcl_DecrRefCount(elemObjPtr); + /* First ensure the name given is valid */ + if (Tcl_FindCommand(interp, name, NULL, TCL_LEAVE_ERR_MSG) == NULL) { + return TCL_ERROR; + } + + resultListPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, + TraceCommandProc, clientData)) != NULL) { + int numOps = 0; + + TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData; - elemObjPtr = Tcl_NewStringObj(tcmdPtr->command, -1); - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); - Tcl_ListObjAppendElement(interp, resultListPtr, - eachTraceObjPtr); + /* + * Build a list with the ops list as the first obj element and the + * tcmdPtr->command string as the second obj element. Append this + * list (as an element) to the end of the result object list. + */ + + elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_IncrRefCount(elemObjPtr); + if (tcmdPtr->flags & TCL_TRACE_RENAME) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("rename",6)); } - Tcl_SetObjResult(interp, resultListPtr); - break; + if (tcmdPtr->flags & TCL_TRACE_DELETE) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("delete",6)); + } + Tcl_ListObjLength(NULL, elemObjPtr, &numOps); + if (0 == numOps) { + Tcl_DecrRefCount(elemObjPtr); + continue; + } + eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + Tcl_DecrRefCount(elemObjPtr); + + elemObjPtr = Tcl_NewStringObj(tcmdPtr->command, -1); + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + Tcl_ListObjAppendElement(interp, resultListPtr, eachTraceObjPtr); } + Tcl_SetObjResult(interp, resultListPtr); + break; + } } return TCL_OK; } - /* *---------------------------------------------------------------------- * * TclTraceVariableObjCmd -- * - * Helper function for Tcl_TraceObjCmd; implements the - * [trace {add|info|remove} variable ...] subcommands. - * See the user documentation for details on what these do. + * Helper function for Tcl_TraceObjCmd; implements the [trace + * {add|info|remove} variable ...] subcommands. See the user + * documentation for details on what these do. * * Results: * Standard Tcl result. * * Side effects: - * Depends on the operation (add, remove, or info) being performed; - * may add or remove variable traces on a variable. + * Depends on the operation (add, remove, or info) being performed; may + * add or remove variable traces on a variable. * *---------------------------------------------------------------------- */ @@ -821,180 +828,179 @@ TclTraceVariableObjCmd(interp, optionIndex, objc, objv) char *name, *command; size_t length; enum traceOptions { TRACE_ADD, TRACE_INFO, TRACE_REMOVE }; - static CONST char *opStrings[] = { "array", "read", "unset", "write", - (char *) NULL }; - enum operations { TRACE_VAR_ARRAY, TRACE_VAR_READ, TRACE_VAR_UNSET, - TRACE_VAR_WRITE }; - + static CONST char *opStrings[] = { + "array", "read", "unset", "write", (char *) NULL + }; + enum operations { + TRACE_VAR_ARRAY, TRACE_VAR_READ, TRACE_VAR_UNSET, TRACE_VAR_WRITE + }; + switch ((enum traceOptions) optionIndex) { - case TRACE_ADD: - case TRACE_REMOVE: { - int flags = 0; - int i, listLen, result; - Tcl_Obj **elemPtrs; - if (objc != 6) { - Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); - return TCL_ERROR; - } - /* - * Make sure the ops argument is a list object; get its length and - * a pointer to its array of element pointers. - */ + case TRACE_ADD: + case TRACE_REMOVE: { + int flags = 0; + int i, listLen, result; + Tcl_Obj **elemPtrs; + + if (objc != 6) { + Tcl_WrongNumArgs(interp, 3, objv, "name opList command"); + return TCL_ERROR; + } - result = Tcl_ListObjGetElements(interp, objv[4], &listLen, - &elemPtrs); - if (result != TCL_OK) { - return result; - } - if (listLen == 0) { - Tcl_SetResult(interp, "bad operation list \"\": must be " - "one or more of array, read, unset, or write", - TCL_STATIC); + /* + * Make sure the ops argument is a list object; get its length and a + * pointer to its array of element pointers. + */ + + result = Tcl_ListObjGetElements(interp, objv[4], &listLen, &elemPtrs); + if (result != TCL_OK) { + return result; + } + if (listLen == 0) { + Tcl_SetResult(interp, "bad operation list \"\": must be " + "one or more of array, read, unset, or write", TCL_STATIC); + return TCL_ERROR; + } + for (i = 0; i < listLen ; i++) { + if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, + "operation", TCL_EXACT, &index) != TCL_OK) { return TCL_ERROR; } - for (i = 0; i < listLen ; i++) { - if (Tcl_GetIndexFromObj(interp, elemPtrs[i], opStrings, - "operation", TCL_EXACT, &index) != TCL_OK) { - return TCL_ERROR; - } - switch ((enum operations) index) { - case TRACE_VAR_ARRAY: - flags |= TCL_TRACE_ARRAY; - break; - case TRACE_VAR_READ: - flags |= TCL_TRACE_READS; - break; - case TRACE_VAR_UNSET: - flags |= TCL_TRACE_UNSETS; - break; - case TRACE_VAR_WRITE: - flags |= TCL_TRACE_WRITES; - break; - } - } - command = Tcl_GetStringFromObj(objv[5], &commandLength); - length = (size_t) commandLength; - if ((enum traceOptions) optionIndex == TRACE_ADD) { - TraceVarInfo *tvarPtr; - tvarPtr = (TraceVarInfo *) ckalloc((unsigned) - (sizeof(TraceVarInfo) - sizeof(tvarPtr->command) - + length + 1)); - tvarPtr->flags = flags; - if (objv[0] == NULL) { - tvarPtr->flags |= TCL_TRACE_OLD_STYLE; - } - tvarPtr->length = length; - flags |= TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT; - strcpy(tvarPtr->command, command); - name = Tcl_GetString(objv[3]); - if (Tcl_TraceVar(interp, name, flags, TraceVarProc, - (ClientData) tvarPtr) != TCL_OK) { - ckfree((char *) tvarPtr); - return TCL_ERROR; - } - } else { - /* - * Search through all of our traces on this variable to - * see if there's one with the given command. If so, then - * delete the first one that matches. - */ - - TraceVarInfo *tvarPtr; - ClientData clientData = 0; - name = Tcl_GetString(objv[3]); - while ((clientData = Tcl_VarTraceInfo(interp, name, 0, - TraceVarProc, clientData)) != 0) { - tvarPtr = (TraceVarInfo *) clientData; - if ((tvarPtr->length == length) - && ((tvarPtr->flags & ~TCL_TRACE_OLD_STYLE)==flags) - && (strncmp(command, tvarPtr->command, - (size_t) length) == 0)) { - Tcl_UntraceVar2(interp, name, NULL, - flags | TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT, - TraceVarProc, clientData); - Tcl_EventuallyFree((ClientData) tvarPtr, TCL_DYNAMIC); - break; - } - } + switch ((enum operations) index) { + case TRACE_VAR_ARRAY: + flags |= TCL_TRACE_ARRAY; + break; + case TRACE_VAR_READ: + flags |= TCL_TRACE_READS; + break; + case TRACE_VAR_UNSET: + flags |= TCL_TRACE_UNSETS; + break; + case TRACE_VAR_WRITE: + flags |= TCL_TRACE_WRITES; + break; } - break; } - case TRACE_INFO: { - ClientData clientData; - Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; - if (objc != 4) { - Tcl_WrongNumArgs(interp, 3, objv, "name"); + command = Tcl_GetStringFromObj(objv[5], &commandLength); + length = (size_t) commandLength; + if ((enum traceOptions) optionIndex == TRACE_ADD) { + TraceVarInfo *tvarPtr; + tvarPtr = (TraceVarInfo *) ckalloc((unsigned) + (sizeof(TraceVarInfo) - sizeof(tvarPtr->command) + + length + 1)); + tvarPtr->flags = flags; + if (objv[0] == NULL) { + tvarPtr->flags |= TCL_TRACE_OLD_STYLE; + } + tvarPtr->length = length; + flags |= TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT; + strcpy(tvarPtr->command, command); + name = Tcl_GetString(objv[3]); + if (Tcl_TraceVar(interp, name, flags, TraceVarProc, + (ClientData) tvarPtr) != TCL_OK) { + ckfree((char *) tvarPtr); return TCL_ERROR; } + } else { + /* + * Search through all of our traces on this variable to see if + * there's one with the given command. If so, then delete the + * first one that matches. + */ - resultListPtr = Tcl_NewObj(); - clientData = 0; + TraceVarInfo *tvarPtr; + ClientData clientData = 0; name = Tcl_GetString(objv[3]); while ((clientData = Tcl_VarTraceInfo(interp, name, 0, TraceVarProc, clientData)) != 0) { + tvarPtr = (TraceVarInfo *) clientData; + if ((tvarPtr->length == length) + && ((tvarPtr->flags & ~TCL_TRACE_OLD_STYLE)==flags) + && (strncmp(command, tvarPtr->command, + (size_t) length) == 0)) { + Tcl_UntraceVar2(interp, name, NULL, + flags | TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT, + TraceVarProc, clientData); + Tcl_EventuallyFree((ClientData) tvarPtr, TCL_DYNAMIC); + break; + } + } + } + break; + } + case TRACE_INFO: { + ClientData clientData; + Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr; - TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData; + if (objc != 4) { + Tcl_WrongNumArgs(interp, 3, objv, "name"); + return TCL_ERROR; + } - /* - * Build a list with the ops list as - * the first obj element and the tcmdPtr->command string - * as the second obj element. Append this list (as an - * element) to the end of the result object list. - */ + resultListPtr = Tcl_NewObj(); + clientData = 0; + name = Tcl_GetString(objv[3]); + while ((clientData = Tcl_VarTraceInfo(interp, name, 0, TraceVarProc, + clientData)) != 0) { - elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - if (tvarPtr->flags & TCL_TRACE_ARRAY) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("array", 5)); - } - if (tvarPtr->flags & TCL_TRACE_READS) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("read", 4)); - } - if (tvarPtr->flags & TCL_TRACE_WRITES) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("write", 5)); - } - if (tvarPtr->flags & TCL_TRACE_UNSETS) { - Tcl_ListObjAppendElement(NULL, elemObjPtr, - Tcl_NewStringObj("unset", 5)); - } - eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData; + + /* + * Build a list with the ops list as the first obj element and the + * tcmdPtr->command string as the second obj element. Append this + * list (as an element) to the end of the result object list. + */ - elemObjPtr = Tcl_NewStringObj(tvarPtr->command, -1); - Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); - Tcl_ListObjAppendElement(interp, resultListPtr, - eachTraceObjPtr); + elemObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + if (tvarPtr->flags & TCL_TRACE_ARRAY) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("array", 5)); } - Tcl_SetObjResult(interp, resultListPtr); - break; + if (tvarPtr->flags & TCL_TRACE_READS) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("read", 4)); + } + if (tvarPtr->flags & TCL_TRACE_WRITES) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("write", 5)); + } + if (tvarPtr->flags & TCL_TRACE_UNSETS) { + Tcl_ListObjAppendElement(NULL, elemObjPtr, + Tcl_NewStringObj("unset", 5)); + } + eachTraceObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + + elemObjPtr = Tcl_NewStringObj(tvarPtr->command, -1); + Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr); + Tcl_ListObjAppendElement(interp, resultListPtr, + eachTraceObjPtr); } + Tcl_SetObjResult(interp, resultListPtr); + break; + } } return TCL_OK; } - /* *---------------------------------------------------------------------- * * Tcl_CommandTraceInfo -- * - * Return the clientData value associated with a trace on a - * command. This procedure can also be used to step through - * all of the traces on a particular command that have the - * same trace procedure. + * Return the clientData value associated with a trace on a command. + * This function can also be used to step through all of the traces on a + * particular command that have the same trace function. * * Results: - * The return value is the clientData value associated with - * a trace on the given command. Information will only be - * returned for a trace with proc as trace procedure. If - * the clientData argument is NULL then the first such trace is - * returned; otherwise, the next relevant one after the one - * given by clientData will be returned. If the command - * doesn't exist then an error message is left in the interpreter - * and NULL is returned. Also, if there are no (more) traces for - * the given command, NULL is returned. + * The return value is the clientData value associated with a trace on + * the given command. Information will only be returned for a trace with + * proc as trace function. If the clientData argument is NULL then the + * first such trace is returned; otherwise, the next relevant one after + * the one given by clientData will be returned. If the command doesn't + * exist then an error message is left in the interpreter and NULL is + * returned. Also, if there are no (more) traces for the given command, + * NULL is returned. * * Side effects: * None. @@ -1008,18 +1014,17 @@ Tcl_CommandTraceInfo(interp, cmdName, flags, proc, prevClientData) CONST char *cmdName; /* Name of command. */ int flags; /* OR-ed combo or TCL_GLOBAL_ONLY, * TCL_NAMESPACE_ONLY (can be 0). */ - Tcl_CommandTraceProc *proc; /* Procedure assocated with trace. */ - ClientData prevClientData; /* If non-NULL, gives last value returned - * by this procedure, so this call will - * return the next trace after that one. - * If NULL, this call will return the - * first trace. */ + Tcl_CommandTraceProc *proc; /* Function assocated with trace. */ + ClientData prevClientData; /* If non-NULL, gives last value returned by + * this function, so this call will return the + * next trace after that one. If NULL, this + * call will return the first trace. */ { Command *cmdPtr; register CommandTrace *tracePtr; - cmdPtr = (Command*)Tcl_FindCommand(interp, cmdName, - NULL, TCL_LEAVE_ERR_MSG); + cmdPtr = (Command *) Tcl_FindCommand(interp, cmdName, NULL, + TCL_LEAVE_ERR_MSG); if (cmdPtr == NULL) { return NULL; } @@ -1030,7 +1035,7 @@ Tcl_CommandTraceInfo(interp, cmdName, flags, proc, prevClientData) tracePtr = cmdPtr->tracePtr; if (prevClientData != NULL) { - for ( ; tracePtr != NULL; tracePtr = tracePtr->nextPtr) { + for (; tracePtr!=NULL ; tracePtr=tracePtr->nextPtr) { if ((tracePtr->clientData == prevClientData) && (tracePtr->traceProc == proc)) { tracePtr = tracePtr->nextPtr; @@ -1038,7 +1043,7 @@ Tcl_CommandTraceInfo(interp, cmdName, flags, proc, prevClientData) } } } - for ( ; tracePtr != NULL; tracePtr = tracePtr->nextPtr) { + for (; tracePtr!=NULL ; tracePtr=tracePtr->nextPtr) { if (tracePtr->traceProc == proc) { return tracePtr->clientData; } @@ -1051,41 +1056,40 @@ Tcl_CommandTraceInfo(interp, cmdName, flags, proc, prevClientData) * * Tcl_TraceCommand -- * - * Arrange for rename/deletes to a command to cause a - * procedure to be invoked, which can monitor the operations. - * - * Also optionally arrange for execution of that command - * to cause a procedure to be invoked. + * Arrange for rename/deletes to a command to cause a function to be + * invoked, which can monitor the operations. + * + * Also optionally arrange for execution of that command to cause a + * function to be invoked. * * Results: * A standard Tcl return value. * * Side effects: - * A trace is set up on the command given by cmdName, such that - * future changes to the command will be intermediated by - * proc. See the manual entry for complete details on the calling - * sequence for proc. + * A trace is set up on the command given by cmdName, such that future + * changes to the command will be intermediated by proc. See the manual + * entry for complete details on the calling sequence for proc. * *---------------------------------------------------------------------- */ int Tcl_TraceCommand(interp, cmdName, flags, proc, clientData) - Tcl_Interp *interp; /* Interpreter in which command is - * to be traced. */ + Tcl_Interp *interp; /* Interpreter in which command is to be + * traced. */ CONST char *cmdName; /* Name of command. */ - int flags; /* OR-ed collection of bits, including any - * of TCL_TRACE_RENAME, TCL_TRACE_DELETE, - * and any of the TRACE_*_EXEC flags */ - Tcl_CommandTraceProc *proc; /* Procedure to call when specified ops are + int flags; /* OR-ed collection of bits, including any of + * TCL_TRACE_RENAME, TCL_TRACE_DELETE, and any + * of the TRACE_*_EXEC flags */ + Tcl_CommandTraceProc *proc; /* Function to call when specified ops are * invoked upon cmdName. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { Command *cmdPtr; register CommandTrace *tracePtr; - cmdPtr = (Command*)Tcl_FindCommand(interp, cmdName, - NULL, TCL_LEAVE_ERR_MSG); + cmdPtr = (Command *) Tcl_FindCommand(interp, cmdName, NULL, + TCL_LEAVE_ERR_MSG); if (cmdPtr == NULL) { return TCL_ERROR; } @@ -1097,13 +1101,13 @@ Tcl_TraceCommand(interp, cmdName, flags, proc, clientData) tracePtr = (CommandTrace *) ckalloc(sizeof(CommandTrace)); tracePtr->traceProc = proc; tracePtr->clientData = clientData; - tracePtr->flags = flags & (TCL_TRACE_RENAME | TCL_TRACE_DELETE - | TCL_TRACE_ANY_EXEC); + tracePtr->flags = flags & + (TCL_TRACE_RENAME | TCL_TRACE_DELETE | TCL_TRACE_ANY_EXEC); tracePtr->nextPtr = cmdPtr->tracePtr; tracePtr->refCount = 1; cmdPtr->tracePtr = tracePtr; if (tracePtr->flags & TCL_TRACE_ANY_EXEC) { - cmdPtr->flags |= CMD_HAS_EXEC_TRACES; + cmdPtr->flags |= CMD_HAS_EXEC_TRACES; } return TCL_OK; } @@ -1119,9 +1123,8 @@ Tcl_TraceCommand(interp, cmdName, flags, proc, clientData) * None. * * Side effects: - * If there exists a trace for the command given by cmdName - * with the given flags, proc, and clientData, then that trace - * is removed. + * If there exists a trace for the command given by cmdName with the + * given flags, proc, and clientData, then that trace is removed. * *---------------------------------------------------------------------- */ @@ -1130,10 +1133,10 @@ void Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) Tcl_Interp *interp; /* Interpreter containing command. */ CONST char *cmdName; /* Name of command. */ - int flags; /* OR-ed collection of bits, including any - * of TCL_TRACE_RENAME, TCL_TRACE_DELETE, - * and any of the TRACE_*_EXEC flags */ - Tcl_CommandTraceProc *proc; /* Procedure assocated with trace. */ + int flags; /* OR-ed collection of bits, including any of + * TCL_TRACE_RENAME, TCL_TRACE_DELETE, and any + * of the TRACE_*_EXEC flags */ + Tcl_CommandTraceProc *proc; /* Function assocated with trace. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { register CommandTrace *tracePtr; @@ -1142,9 +1145,9 @@ Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) Interp *iPtr = (Interp *) interp; ActiveCommandTrace *activePtr; int hasExecTraces = 0; - - cmdPtr = (Command*)Tcl_FindCommand(interp, cmdName, - NULL, TCL_LEAVE_ERR_MSG); + + cmdPtr = (Command*)Tcl_FindCommand(interp, cmdName, NULL, + TCL_LEAVE_ERR_MSG); if (cmdPtr == NULL) { return; } @@ -1152,13 +1155,13 @@ Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) flags &= (TCL_TRACE_RENAME | TCL_TRACE_DELETE | TCL_TRACE_ANY_EXEC); for (tracePtr = cmdPtr->tracePtr, prevPtr = NULL; ; - prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { + prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { if (tracePtr == NULL) { return; } - if ((tracePtr->traceProc == proc) - && ((tracePtr->flags & (TCL_TRACE_RENAME | TCL_TRACE_DELETE | - TCL_TRACE_ANY_EXEC)) == flags) + if ((tracePtr->traceProc == proc) + && ((tracePtr->flags & (TCL_TRACE_RENAME | TCL_TRACE_DELETE | + TCL_TRACE_ANY_EXEC)) == flags) && (tracePtr->clientData == clientData)) { if (tracePtr->flags & TCL_TRACE_ANY_EXEC) { hasExecTraces = 1; @@ -1166,15 +1169,15 @@ Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) break; } } - + /* - * The code below makes it possible to delete traces while traces - * are active: it makes sure that the deleted trace won't be - * processed by CallCommandTraces. + * The code below makes it possible to delete traces while traces are + * active: it makes sure that the deleted trace won't be processed by + * CallCommandTraces. */ for (activePtr = iPtr->activeCmdTracePtr; activePtr != NULL; - activePtr = activePtr->nextPtr) { + activePtr = activePtr->nextPtr) { if (activePtr->nextTracePtr == tracePtr) { if (activePtr->reverseScan) { activePtr->nextTracePtr = prevPtr; @@ -1189,22 +1192,24 @@ Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) prevPtr->nextPtr = tracePtr->nextPtr; } tracePtr->flags = 0; - + if ((--tracePtr->refCount) <= 0) { ckfree((char*)tracePtr); } - + if (hasExecTraces) { for (tracePtr = cmdPtr->tracePtr, prevPtr = NULL; tracePtr != NULL ; - prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { + prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { if (tracePtr->flags & TCL_TRACE_ANY_EXEC) { - return; + return; } } - /* - * None of the remaining traces on this command are execution - * traces. We therefore remove this flag: + + /* + * None of the remaining traces on this command are execution traces. + * We therefore remove this flag: */ + cmdPtr->flags &= ~CMD_HAS_EXEC_TRACES; } } @@ -1214,9 +1219,9 @@ Tcl_UntraceCommand(interp, cmdName, flags, proc, clientData) * * TraceCommandProc -- * - * This procedure is called to handle command changes that have - * been traced using the "trace" command, when using the - * 'rename' or 'delete' options. + * This function is called to handle command changes that have been + * traced using the "trace" command, when using the 'rename' or 'delete' + * options. * * Results: * None. @@ -1233,23 +1238,23 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) ClientData clientData; /* Information about the command trace. */ Tcl_Interp *interp; /* Interpreter containing command. */ CONST char *oldName; /* Name of command being changed. */ - CONST char *newName; /* New name of command. Empty string - * or NULL means command is being deleted - * (renamed to ""). */ + CONST char *newName; /* New name of command. Empty string or NULL + * means command is being deleted (renamed to + * ""). */ int flags; /* OR-ed bits giving operation and other * information. */ { TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData; int code; Tcl_DString cmd; - + tcmdPtr->refCount++; - + if ((tcmdPtr->flags & flags) && !(flags & TCL_INTERP_DESTROYED) && !Tcl_LimitExceeded(interp)) { /* - * Generate a command to execute by appending list elements - * for the old and new command name and the operation. + * Generate a command to execute by appending list elements for the + * old and new command name and the operation. */ Tcl_DStringInit(&cmd); @@ -1263,12 +1268,12 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) } /* - * Execute the command. - * We discard any object result the command returns. + * Execute the command. We discard any object result the command + * returns. * - * Add the TCL_TRACE_DESTROYED flag to tcmdPtr to indicate to - * other areas that this will be destroyed by us, otherwise a - * double-free might occur depending on what the eval does. + * Add the TCL_TRACE_DESTROYED flag to tcmdPtr to indicate to other + * areas that this will be destroyed by us, otherwise a double-free + * might occur depending on what the eval does. */ if (flags & TCL_TRACE_DESTROYED) { @@ -1276,16 +1281,18 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) } code = Tcl_EvalEx(interp, Tcl_DStringValue(&cmd), Tcl_DStringLength(&cmd), 0); - if (code != TCL_OK) { + if (code != TCL_OK) { /* We ignore errors in these traced commands */ /*** QUESTION: Use Tcl_BackgroundError(interp); instead? ***/ } Tcl_DStringFree(&cmd); } + /* * We delete when the trace was destroyed or if this is a delete trace, * because command deletes are unconditional, so the trace must go away. */ + if (flags & (TCL_TRACE_DESTROYED | TCL_TRACE_DELETE)) { int untraceFlags = tcmdPtr->flags; Tcl_InterpState state; @@ -1293,37 +1300,43 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) if (tcmdPtr->stepTrace != NULL) { Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); tcmdPtr->stepTrace = NULL; - if (tcmdPtr->startCmd != NULL) { - ckfree((char *)tcmdPtr->startCmd); + if (tcmdPtr->startCmd != NULL) { + ckfree((char *)tcmdPtr->startCmd); } } if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) { - /* Postpone deletion, until exec trace returns */ + /* + * Postpone deletion, until exec trace returns. + */ + tcmdPtr->flags = 0; } + /* - * We need to construct the same flags for Tcl_UntraceCommand - * as were passed to Tcl_TraceCommand. Reproduce the processing - * of [trace add execution/command]. Be careful to keep this - * code in sync with that. + * We need to construct the same flags for Tcl_UntraceCommand as were + * passed to Tcl_TraceCommand. Reproduce the processing of [trace add + * execution/command]. Be careful to keep this code in sync with that. */ + if (untraceFlags & TCL_TRACE_ANY_EXEC) { untraceFlags |= TCL_TRACE_DELETE; - if (untraceFlags & (TCL_TRACE_ENTER_DURING_EXEC + if (untraceFlags & (TCL_TRACE_ENTER_DURING_EXEC | TCL_TRACE_LEAVE_DURING_EXEC)) { untraceFlags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC); } } else if (untraceFlags & TCL_TRACE_RENAME) { untraceFlags |= TCL_TRACE_DELETE; } + /* * Remove the trace since TCL_TRACE_DESTROYED tells us to, or the - * command we're tracing has just gone away. Then decrement the + * command we're tracing has just gone away. Then decrement the * clientData refCount that was set up by trace creation. * - * Note that we save the (return) state of the interpreter to - * prevent bizarre error messages. + * Note that we save the (return) state of the interpreter to prevent + * bizarre error messages. */ + state = Tcl_SaveInterpState(interp, TCL_OK); Tcl_UntraceCommand(interp, oldName, untraceFlags, TraceCommandProc, clientData); @@ -1331,7 +1344,7 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) tcmdPtr->refCount--; } if ((--tcmdPtr->refCount) <= 0) { - ckfree((char*)tcmdPtr); + ckfree((char*)tcmdPtr); } return; } @@ -1341,37 +1354,37 @@ TraceCommandProc(clientData, interp, oldName, newName, flags) * * TclCheckExecutionTraces -- * - * Checks on all current command execution traces, and invokes - * procedures which have been registered. This procedure can be - * used by other code which performs execution to unify the - * tracing system, so that execution traces will function for that - * other code. - * - * For instance extensions like [incr Tcl] which use their - * own execution technique can make use of Tcl's tracing. - * - * This procedure is called by 'TclEvalObjvInternal' + * Checks on all current command execution traces, and invokes functions + * which have been registered. This function can be used by other code + * which performs execution to unify the tracing system, so that + * execution traces will function for that other code. + * + * For instance extensions like [incr Tcl] which use their own execution + * technique can make use of Tcl's tracing. + * + * This function is called by 'TclEvalObjvInternal' * * Results: - * The return value is a standard Tcl completion code such as - * TCL_OK or TCL_ERROR, etc. + * The return value is a standard Tcl completion code such as TCL_OK or + * TCL_ERROR, etc. * * Side effects: - * Those side effects made by any trace procedures called. + * Those side effects made by any trace functions called. * *---------------------------------------------------------------------- */ -int -TclCheckExecutionTraces(interp, command, numChars, cmdPtr, code, - traceFlags, objc, objv) + +int +TclCheckExecutionTraces(interp, command, numChars, cmdPtr, code, traceFlags, + objc, objv) Tcl_Interp *interp; /* The current interpreter. */ - CONST char *command; /* Pointer to beginning of the current - * command string. */ - int numChars; /* The number of characters in 'command' - * which are part of the command string. */ + CONST char *command; /* Pointer to beginning of the current command + * string. */ + int numChars; /* The number of characters in 'command' which + * are part of the command string. */ Command *cmdPtr; /* Points to command's Command struct. */ - int code; /* The current result code. */ - int traceFlags; /* Current tracing situation. */ + int code; /* The current result code. */ + int traceFlags; /* Current tracing situation. */ int objc; /* Number of arguments for the command. */ Tcl_Obj *CONST objv[]; /* Pointers to Tcl_Obj of each argument. */ { @@ -1382,46 +1395,49 @@ TclCheckExecutionTraces(interp, command, numChars, cmdPtr, code, int traceCode = TCL_OK; TraceCommandInfo* tcmdPtr; Tcl_InterpState state = NULL; - + if (command == NULL || cmdPtr->tracePtr == NULL) { return traceCode; } - + curLevel = ((iPtr->varFramePtr == NULL) ? 0 : iPtr->varFramePtr->level); - + active.nextPtr = iPtr->activeCmdTracePtr; iPtr->activeCmdTracePtr = &active; active.cmdPtr = cmdPtr; lastTracePtr = NULL; - for (tracePtr = cmdPtr->tracePtr; - (traceCode == TCL_OK) && (tracePtr != NULL); - tracePtr = active.nextTracePtr) { - if (traceFlags & TCL_TRACE_LEAVE_EXEC) { - /* execute the trace command in order of creation for "leave" */ + for (tracePtr = cmdPtr->tracePtr; + (traceCode == TCL_OK) && (tracePtr != NULL); + tracePtr = active.nextTracePtr) { + if (traceFlags & TCL_TRACE_LEAVE_EXEC) { + /* + * Execute the trace command in order of creation for "leave". + */ + active.reverseScan = 1; active.nextTracePtr = NULL; - tracePtr = cmdPtr->tracePtr; - while (tracePtr->nextPtr != lastTracePtr) { - active.nextTracePtr = tracePtr; - tracePtr = tracePtr->nextPtr; - } - } else { + tracePtr = cmdPtr->tracePtr; + while (tracePtr->nextPtr != lastTracePtr) { + active.nextTracePtr = tracePtr; + tracePtr = tracePtr->nextPtr; + } + } else { active.reverseScan = 0; active.nextTracePtr = tracePtr->nextPtr; - } + } tcmdPtr = (TraceCommandInfo*)tracePtr->clientData; if (tcmdPtr->flags != 0) { - tcmdPtr->curFlags = traceFlags | TCL_TRACE_EXEC_DIRECT; - tcmdPtr->curCode = code; + tcmdPtr->curFlags = traceFlags | TCL_TRACE_EXEC_DIRECT; + tcmdPtr->curCode = code; tcmdPtr->refCount++; if (state == NULL) { state = Tcl_SaveInterpState(interp, code); } - traceCode = TraceExecutionProc((ClientData)tcmdPtr, interp, - curLevel, command, (Tcl_Command)cmdPtr, objc, objv); + traceCode = TraceExecutionProc((ClientData)tcmdPtr, interp, + curLevel, command, (Tcl_Command)cmdPtr, objc, objv); if ((--tcmdPtr->refCount) <= 0) { - ckfree((char*)tcmdPtr); + ckfree((char*)tcmdPtr); } } if (active.nextTracePtr) { @@ -1440,34 +1456,35 @@ TclCheckExecutionTraces(interp, command, numChars, cmdPtr, code, * * TclCheckInterpTraces -- * - * Checks on all current traces, and invokes procedures which - * have been registered. This procedure can be used by other - * code which performs execution to unify the tracing system. - * For instance extensions like [incr Tcl] which use their - * own execution technique can make use of Tcl's tracing. - * - * This procedure is called by 'TclEvalObjvInternal' + * Checks on all current traces, and invokes functions which have been + * registered. This function can be used by other code which performs + * execution to unify the tracing system. For instance extensions like + * [incr Tcl] which use their own execution technique can make use of + * Tcl's tracing. + * + * This function is called by 'TclEvalObjvInternal' * * Results: - * The return value is a standard Tcl completion code such as - * TCL_OK or TCL_ERROR, etc. + * The return value is a standard Tcl completion code such as TCL_OK or + * TCL_ERROR, etc. * * Side effects: - * Those side effects made by any trace procedures called. + * Those side effects made by any trace functions called. * *---------------------------------------------------------------------- */ -int -TclCheckInterpTraces(interp, command, numChars, cmdPtr, code, - traceFlags, objc, objv) + +int +TclCheckInterpTraces(interp, command, numChars, cmdPtr, code, traceFlags, + objc, objv) Tcl_Interp *interp; /* The current interpreter. */ - CONST char *command; /* Pointer to beginning of the current - * command string. */ - int numChars; /* The number of characters in 'command' - * which are part of the command string. */ + CONST char *command; /* Pointer to beginning of the current command + * string. */ + int numChars; /* The number of characters in 'command' which + * are part of the command string. */ Command *cmdPtr; /* Points to command's Command struct. */ - int code; /* The current result code. */ - int traceFlags; /* Current tracing situation. */ + int code; /* The current result code. */ + int traceFlags; /* Current tracing situation. */ int objc; /* Number of arguments for the command. */ Tcl_Obj *CONST objv[]; /* Pointers to Tcl_Obj of each argument. */ { @@ -1477,60 +1494,68 @@ TclCheckInterpTraces(interp, command, numChars, cmdPtr, code, int curLevel; int traceCode = TCL_OK; Tcl_InterpState state = NULL; - - if (command == NULL || iPtr->tracePtr == NULL || - (iPtr->flags & INTERP_TRACE_IN_PROGRESS)) { + + if (command == NULL || iPtr->tracePtr == NULL + || (iPtr->flags & INTERP_TRACE_IN_PROGRESS)) { return(traceCode); } - + curLevel = iPtr->numLevels; - + active.nextPtr = iPtr->activeInterpTracePtr; iPtr->activeInterpTracePtr = &active; lastTracePtr = NULL; - for ( tracePtr = iPtr->tracePtr; - (traceCode == TCL_OK) && (tracePtr != NULL); - tracePtr = active.nextTracePtr) { - if (traceFlags & TCL_TRACE_ENTER_EXEC) { - /* - * Execute the trace command in reverse order of creation - * for "enterstep" operation. The order is changed for - * "enterstep" instead of for "leavestep" as was done in - * TclCheckExecutionTraces because for step traces, - * Tcl_CreateObjTrace creates one more linked list of traces - * which results in one more reversal of trace invocation. - */ + for (tracePtr = iPtr->tracePtr; + (traceCode == TCL_OK) && (tracePtr != NULL); + tracePtr = active.nextTracePtr) { + if (traceFlags & TCL_TRACE_ENTER_EXEC) { + /* + * Execute the trace command in reverse order of creation for + * "enterstep" operation. The order is changed for "enterstep" + * instead of for "leavestep" as was done in + * TclCheckExecutionTraces because for step traces, + * Tcl_CreateObjTrace creates one more linked list of traces which + * results in one more reversal of trace invocation. + */ + active.reverseScan = 1; active.nextTracePtr = NULL; - tracePtr = iPtr->tracePtr; - while (tracePtr->nextPtr != lastTracePtr) { - active.nextTracePtr = tracePtr; - tracePtr = tracePtr->nextPtr; - } - } else { + tracePtr = iPtr->tracePtr; + while (tracePtr->nextPtr != lastTracePtr) { + active.nextTracePtr = tracePtr; + tracePtr = tracePtr->nextPtr; + } + } else { active.reverseScan = 0; active.nextTracePtr = tracePtr->nextPtr; - } + } + if (tracePtr->level > 0 && curLevel > tracePtr->level) { continue; } + if (!(tracePtr->flags & TCL_TRACE_EXEC_IN_PROGRESS)) { - /* - * The proc invoked might delete the traced command which - * which might try to free tracePtr. We want to use tracePtr - * until the end of this if section, so we use - * Tcl_Preserve() and Tcl_Release() to be sure it is not - * freed while we still need it. + /* + * The proc invoked might delete the traced command which which + * might try to free tracePtr. We want to use tracePtr until the + * end of this if section, so we use Tcl_Preserve() and + * Tcl_Release() to be sure it is not freed while we still need + * it. */ + Tcl_Preserve((ClientData) tracePtr); tracePtr->flags |= TCL_TRACE_EXEC_IN_PROGRESS; if (state == NULL) { state = Tcl_SaveInterpState(interp, code); } - - if (tracePtr->flags & (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC)) { - /* New style trace */ + + if (tracePtr->flags & + (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC)) { + /* + * New style trace. + */ + if (tracePtr->flags & traceFlags) { if (tracePtr->proc == TraceExecutionProc) { TraceCommandInfo* tcmdPtr = @@ -1543,15 +1568,18 @@ TclCheckInterpTraces(interp, command, numChars, cmdPtr, code, objc, objv); } } else { - /* Old-style trace */ - + /* + * Old-style trace. + */ + if (traceFlags & TCL_TRACE_ENTER_EXEC) { - /* - * Old-style interpreter-wide traces only trigger - * before the command is executed. + /* + * Old-style interpreter-wide traces only trigger before + * the command is executed. */ - traceCode = CallTraceProcedure(interp, tracePtr, cmdPtr, - command, numChars, objc, objv); + + traceCode = CallTraceFunction(interp, tracePtr, cmdPtr, + command, numChars, objc, objv); } } tracePtr->flags &= ~TCL_TRACE_EXEC_IN_PROGRESS; @@ -1575,31 +1603,31 @@ TclCheckInterpTraces(interp, command, numChars, cmdPtr, code, /* *---------------------------------------------------------------------- * - * CallTraceProcedure -- + * CallTraceFunction -- * - * Invokes a trace procedure registered with an interpreter. These - * procedures trace command execution. Currently this trace procedure - * is called with the address of the string-based Tcl_CmdProc for the + * Invokes a trace function registered with an interpreter. These + * functions trace command execution. Currently this trace function is + * called with the address of the string-based Tcl_CmdProc for the * command, not the Tcl_ObjCmdProc. * * Results: * None. * * Side effects: - * Those side effects made by the trace procedure. + * Those side effects made by the trace function. * *---------------------------------------------------------------------- */ static int -CallTraceProcedure(interp, tracePtr, cmdPtr, command, numChars, objc, objv) +CallTraceFunction(interp, tracePtr, cmdPtr, command, numChars, objc, objv) Tcl_Interp *interp; /* The current interpreter. */ - register Trace *tracePtr; /* Describes the trace procedure to call. */ + register Trace *tracePtr; /* Describes the trace function to call. */ Command *cmdPtr; /* Points to command's Command struct. */ CONST char *command; /* Points to the first character of the * command's source before substitutions. */ - int numChars; /* The number of characters in the - * command's source. */ + int numChars; /* The number of characters in the command's + * source. */ register int objc; /* Number of arguments for the command. */ Tcl_Obj *CONST objv[]; /* Pointers to Tcl_Obj of each argument. */ { @@ -1607,21 +1635,20 @@ CallTraceProcedure(interp, tracePtr, cmdPtr, command, numChars, objc, objv) char *commandCopy; int traceCode; - /* + /* * Copy the command characters into a new string. */ commandCopy = (char *) ckalloc((unsigned) (numChars + 1)); memcpy((VOID *) commandCopy, (VOID *) command, (size_t) numChars); commandCopy[numChars] = '\0'; - + /* - * Call the trace procedure then free allocated storage. + * Call the trace function then free allocated storage. */ - - traceCode = (tracePtr->proc)( tracePtr->clientData, (Tcl_Interp*) iPtr, - iPtr->numLevels, commandCopy, - (Tcl_Command) cmdPtr, objc, objv ); + + traceCode = (tracePtr->proc)(tracePtr->clientData, (Tcl_Interp*) iPtr, + iPtr->numLevels, commandCopy, (Tcl_Command) cmdPtr, objc, objv); ckfree((char *) commandCopy); return(traceCode); @@ -1632,18 +1659,19 @@ CallTraceProcedure(interp, tracePtr, cmdPtr, command, numChars, objc, objv) * * CommandObjTraceDeleted -- * - * Ensure the trace is correctly deleted by decrementing its - * refCount and only deleting if no other references exist. + * Ensure the trace is correctly deleted by decrementing its refCount and + * only deleting if no other references exist. * * Results: - * None. + * None. * * Side effects: * May release memory. * *---------------------------------------------------------------------- */ -static void + +static void CommandObjTraceDeleted(ClientData clientData) { TraceCommandInfo* tcmdPtr = (TraceCommandInfo*)clientData; if ((--tcmdPtr->refCount) <= 0) { @@ -1656,80 +1684,82 @@ CommandObjTraceDeleted(ClientData clientData) { * * TraceExecutionProc -- * - * This procedure is invoked whenever code relevant to a - * 'trace execution' command is executed. It is called in one - * of two ways in Tcl's core: - * - * (i) by the TclCheckExecutionTraces, when an execution trace - * has been triggered. - * (ii) by TclCheckInterpTraces, when a prior execution trace has - * created a trace of the internals of a procedure, passing in - * this procedure as the one to be called. + * This function is invoked whenever code relevant to a 'trace execution' + * command is executed. It is called in one of two ways in Tcl's core: + * + * (i) by the TclCheckExecutionTraces, when an execution trace has been + * triggered. + * (ii) by TclCheckInterpTraces, when a prior execution trace has created + * a trace of the internals of a procedure, passing in this function as + * the one to be called. * * Results: - * The return value is a standard Tcl completion code such as - * TCL_OK or TCL_ERROR, etc. + * The return value is a standard Tcl completion code such as TCL_OK or + * TCL_ERROR, etc. * * Side effects: - * May invoke an arbitrary Tcl procedure, and may create or - * delete an interpreter-wide trace. + * May invoke an arbitrary Tcl procedure, and may create or delete an + * interpreter-wide trace. * *---------------------------------------------------------------------- */ + static int -TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, - int level, CONST char* command, Tcl_Command cmdInfo, - int objc, struct Tcl_Obj *CONST objv[]) { +TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, int level, + CONST char* command, Tcl_Command cmdInfo, int objc, + struct Tcl_Obj *CONST objv[]) { int call = 0; Interp *iPtr = (Interp *) interp; TraceCommandInfo* tcmdPtr = (TraceCommandInfo*)clientData; int flags = tcmdPtr->curFlags; int code = tcmdPtr->curCode; int traceCode = TCL_OK; - + if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) { - /* - * Inside any kind of execution trace callback, we do - * not allow any further execution trace callbacks to - * be called for the same trace. + /* + * Inside any kind of execution trace callback, we do not allow any + * further execution trace callbacks to be called for the same trace. */ + return traceCode; } - + if (!(flags & TCL_INTERP_DESTROYED) && !Tcl_LimitExceeded(interp)) { /* - * Check whether the current call is going to eval arbitrary - * Tcl code with a generated trace, or whether we are only - * going to setup interpreter-wide traces to implement the - * 'step' traces. This latter situation can happen if - * we create a command trace without either before or after - * operations, but with either of the step operations. + * Check whether the current call is going to eval arbitrary Tcl code + * with a generated trace, or whether we are only going to setup + * interpreter-wide traces to implement the 'step' traces. This latter + * situation can happen if we create a command trace without either + * before or after operations, but with either of the step operations. */ + if (flags & TCL_TRACE_EXEC_DIRECT) { - call = flags & tcmdPtr->flags & (TCL_TRACE_ENTER_EXEC | - TCL_TRACE_LEAVE_EXEC); + call = flags & tcmdPtr->flags & + (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC); } else { call = 1; } + /* - * First, if we have returned back to the level at which we - * created an interpreter trace for enterstep and/or leavestep - * execution traces, we remove it here. + * First, if we have returned back to the level at which we created an + * interpreter trace for enterstep and/or leavestep execution traces, + * we remove it here. */ - if (flags & TCL_TRACE_LEAVE_EXEC) { - if ((tcmdPtr->stepTrace != NULL) && (level == tcmdPtr->startLevel) - && (strcmp(command, tcmdPtr->startCmd) == 0)) { - Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); - tcmdPtr->stepTrace = NULL; - if (tcmdPtr->startCmd != NULL) { - ckfree((char *)tcmdPtr->startCmd); - } + + if ((flags & TCL_TRACE_LEAVE_EXEC) && (tcmdPtr->stepTrace != NULL) + && (level == tcmdPtr->startLevel) + && (strcmp(command, tcmdPtr->startCmd) == 0)) { + Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); + tcmdPtr->stepTrace = NULL; + if (tcmdPtr->startCmd != NULL) { + ckfree((char *)tcmdPtr->startCmd); } } - + /* * Second, create the tcl callback, if required. */ + if (call) { Tcl_DString cmd; Tcl_DString sub; @@ -1737,19 +1767,23 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, Tcl_DStringInit(&cmd); Tcl_DStringAppend(&cmd, tcmdPtr->command, (int)tcmdPtr->length); - /* Append command with arguments */ + + /* + * Append command with arguments. + */ + Tcl_DStringInit(&sub); for (i = 0; i < objc; i++) { - char* str; - int len; - str = Tcl_GetStringFromObj(objv[i],&len); - Tcl_DStringAppendElement(&sub, str); + Tcl_DStringAppendElement(&sub, Tcl_GetString(objv[i])); } Tcl_DStringAppendElement(&cmd, Tcl_DStringValue(&sub)); Tcl_DStringFree(&sub); if (flags & TCL_TRACE_ENTER_EXEC) { - /* Append trace operation */ + /* + * Append trace operation. + */ + if (flags & TCL_TRACE_EXEC_DIRECT) { Tcl_DStringAppendElement(&cmd, "enter"); } else { @@ -1759,15 +1793,25 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, Tcl_Obj* resultCode; char* resultCodeStr; - /* Append result code */ + /* + * Append result code. + */ + resultCode = Tcl_NewIntObj(code); resultCodeStr = Tcl_GetString(resultCode); Tcl_DStringAppendElement(&cmd, resultCodeStr); Tcl_DecrRefCount(resultCode); - - /* Append result string */ + + /* + * Append result string. + */ + Tcl_DStringAppendElement(&cmd, Tcl_GetStringResult(interp)); - /* Append trace operation */ + + /* + * Append trace operation. + */ + if (flags & TCL_TRACE_EXEC_DIRECT) { Tcl_DStringAppendElement(&cmd, "leave"); } else { @@ -1776,20 +1820,22 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, } else { Tcl_Panic("TraceExecutionProc: bad flag combination"); } - + /* - * Execute the command. - * We discard any object result the command returns. + * Execute the command. We discard any object result the command + * returns. */ tcmdPtr->flags |= TCL_TRACE_EXEC_IN_PROGRESS; iPtr->flags |= INTERP_TRACE_IN_PROGRESS; tcmdPtr->refCount++; - /* - * This line can have quite arbitrary side-effects, - * including deleting the trace, the command being - * traced, or even the interpreter. + + /* + * This line can have quite arbitrary side-effects, including + * deleting the trace, the command being traced, or even the + * interpreter. */ + traceCode = Tcl_Eval(interp, Tcl_DStringValue(&cmd)); tcmdPtr->flags &= ~TCL_TRACE_EXEC_IN_PROGRESS; iPtr->flags &= ~INTERP_TRACE_IN_PROGRESS; @@ -1798,26 +1844,26 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, } Tcl_DStringFree(&cmd); } - + /* - * Third, if there are any step execution traces for this proc, - * we register an interpreter trace to invoke enterstep and/or - * leavestep traces. - * We also need to save the current stack level and the proc - * string in startLevel and startCmd so that we can delete this - * interpreter trace when it reaches the end of this proc. + * Third, if there are any step execution traces for this proc, we + * register an interpreter trace to invoke enterstep and/or leavestep + * traces. We also need to save the current stack level and the proc + * string in startLevel and startCmd so that we can delete this + * interpreter trace when it reaches the end of this proc. */ + if ((flags & TCL_TRACE_ENTER_EXEC) && (tcmdPtr->stepTrace == NULL) - && (tcmdPtr->flags & (TCL_TRACE_ENTER_DURING_EXEC | - TCL_TRACE_LEAVE_DURING_EXEC))) { - tcmdPtr->startLevel = level; - tcmdPtr->startCmd = + && (tcmdPtr->flags & (TCL_TRACE_ENTER_DURING_EXEC | + TCL_TRACE_LEAVE_DURING_EXEC))) { + tcmdPtr->startLevel = level; + tcmdPtr->startCmd = (char *) ckalloc((unsigned) (strlen(command) + 1)); - strcpy(tcmdPtr->startCmd, command); - tcmdPtr->refCount++; - tcmdPtr->stepTrace = Tcl_CreateObjTrace(interp, 0, - (tcmdPtr->flags & TCL_TRACE_ANY_EXEC) >> 2, - TraceExecutionProc, (ClientData)tcmdPtr, + strcpy(tcmdPtr->startCmd, command); + tcmdPtr->refCount++; + tcmdPtr->stepTrace = Tcl_CreateObjTrace(interp, 0, + (tcmdPtr->flags & TCL_TRACE_ANY_EXEC) >> 2, + TraceExecutionProc, (ClientData)tcmdPtr, CommandObjTraceDeleted); } } @@ -1825,8 +1871,8 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, if (tcmdPtr->stepTrace != NULL) { Tcl_DeleteTrace(interp, tcmdPtr->stepTrace); tcmdPtr->stepTrace = NULL; - if (tcmdPtr->startCmd != NULL) { - ckfree((char *)tcmdPtr->startCmd); + if (tcmdPtr->startCmd != NULL) { + ckfree((char *)tcmdPtr->startCmd); } } } @@ -1843,12 +1889,12 @@ TraceExecutionProc(ClientData clientData, Tcl_Interp *interp, * * TraceVarProc -- * - * This procedure is called to handle variable accesses that have - * been traced using the "trace" command. + * This function is called to handle variable accesses that have been + * traced using the "trace" command. * * Results: - * Normally returns NULL. If the trace command returns an error, - * then this procedure returns an error string. + * Normally returns NULL. If the trace command returns an error, then + * this function returns an error string. * * Side effects: * Depends on the command associated with the trace. @@ -1862,7 +1908,7 @@ TraceVarProc(clientData, interp, name1, name2, flags) ClientData clientData; /* Information about the variable trace. */ Tcl_Interp *interp; /* Interpreter containing variable. */ CONST char *name1; /* Name of variable or array. */ - CONST char *name2; /* Name of element within array; NULL means + CONST char *name2; /* Name of element within array; NULL means * scalar variable is being referenced. */ int flags; /* OR-ed bits giving operation and other * information. */ @@ -1872,12 +1918,11 @@ TraceVarProc(clientData, interp, name1, name2, flags) int code; Tcl_DString cmd; - /* - * We might call Tcl_Eval() below, and that might evaluate - * [trace vdelete] which might try to free tvarPtr. We want - * to use tvarPtr until the end of this function, so we use - * Tcl_Preserve() and Tcl_Release() to be sure it is not - * freed while we still need it. + /* + * We might call Tcl_Eval() below, and that might evaluate [trace vdelete] + * which might try to free tvarPtr. We want to use tvarPtr until the end + * of this function, so we use Tcl_Preserve() and Tcl_Release() to be sure + * it is not freed while we still need it. */ Tcl_Preserve((ClientData) tvarPtr); @@ -1887,8 +1932,8 @@ TraceVarProc(clientData, interp, name1, name2, flags) && !Tcl_LimitExceeded(interp)) { if (tvarPtr->length != (size_t) 0) { /* - * Generate a command to execute by appending list elements - * for the two variable names and the operation. + * Generate a command to execute by appending list elements for + * the two variable names and the operation. */ Tcl_DStringInit(&cmd); @@ -1920,10 +1965,10 @@ TraceVarProc(clientData, interp, name1, name2, flags) #ifndef TCL_REMOVE_OBSOLETE_TRACES } #endif - + /* - * Execute the command. - * We discard any object result the command returns. + * Execute the command. We discard any object result the command + * returns. * * Add the TCL_TRACE_DESTROYED flag to tvarPtr to indicate to * other areas that this will be destroyed by us, otherwise a @@ -1935,7 +1980,7 @@ TraceVarProc(clientData, interp, name1, name2, flags) } code = Tcl_EvalEx(interp, Tcl_DStringValue(&cmd), Tcl_DStringLength(&cmd), 0); - if (code != TCL_OK) { /* copy error msg to result */ + if (code != TCL_OK) { /* copy error msg to result */ Tcl_Obj *errMsgObj = Tcl_GetObjResult(interp); Tcl_IncrRefCount(errMsgObj); result = (char *) errMsgObj; @@ -1961,88 +2006,86 @@ TraceVarProc(clientData, interp, name1, name2, flags) * * Tcl_CreateObjTrace -- * - * Arrange for a procedure to be called to trace command execution. + * Arrange for a function to be called to trace command execution. * * Results: - * The return value is a token for the trace, which may be passed - * to Tcl_DeleteTrace to eliminate the trace. + * The return value is a token for the trace, which may be passed to + * Tcl_DeleteTrace to eliminate the trace. * * Side effects: - * From now on, proc will be called just before a command procedure - * is called to execute a Tcl command. Calls to proc will have the - * following form: - * - * void proc( ClientData clientData, - * Tcl_Interp* interp, - * int level, - * CONST char* command, - * Tcl_Command commandInfo, - * int objc, - * Tcl_Obj *CONST objv[] ); - * - * The 'clientData' and 'interp' arguments to 'proc' will be the - * same as the arguments to Tcl_CreateObjTrace. The 'level' - * argument gives the nesting depth of command interpretation within - * the interpreter. The 'command' argument is the ASCII text of - * the command being evaluated -- before any substitutions are - * performed. The 'commandInfo' argument gives a handle to the - * command procedure that will be evaluated. The 'objc' and 'objv' - * parameters give the parameter vector that will be passed to the - * command procedure. proc does not return a value. - * - * It is permissible for 'proc' to call Tcl_SetCommandTokenInfo - * to change the command procedure or client data for the command - * being evaluated, and these changes will take effect with the - * current evaluation. - * - * The 'level' argument specifies the maximum nesting level of calls - * to be traced. If the execution depth of the interpreter exceeds - * 'level', the trace callback is not executed. - * - * The 'flags' argument is either zero or the value, - * TCL_ALLOW_INLINE_COMPILATION. If the TCL_ALLOW_INLINE_COMPILATION - * flag is not present, the bytecode compiler will not generate inline - * code for Tcl's built-in commands. This behavior will have a significant - * impact on performance, but will ensure that all command evaluations are - * traced. If the TCL_ALLOW_INLINE_COMPILATION flag is present, the - * bytecode compiler will have its normal behavior of compiling in-line - * code for some of Tcl's built-in commands. In this case, the tracing - * will be imprecise -- in-line code will not be traced -- but run-time - * performance will be improved. The latter behavior is desired for - * many applications such as profiling of run time. - * - * When the trace is deleted, the 'delProc' procedure will be invoked, - * passing it the original client data. + * From now on, proc will be called just before a command function is + * called to execute a Tcl command. Calls to proc will have the following + * form: + * + * void proc(ClientData clientData, + * Tcl_Interp* interp, + * int level, + * CONST char* command, + * Tcl_Command commandInfo, + * int objc, + * Tcl_Obj *CONST objv[]); + * + * The 'clientData' and 'interp' arguments to 'proc' will be the same as + * the arguments to Tcl_CreateObjTrace. The 'level' argument gives the + * nesting depth of command interpretation within the interpreter. The + * 'command' argument is the ASCII text of the command being evaluated - + * before any substitutions are performed. The 'commandInfo' argument + * gives a handle to the command procedure that will be evaluated. The + * 'objc' and 'objv' parameters give the parameter vector that will be + * passed to the command procedure. Proc does not return a value. + * + * It is permissible for 'proc' to call Tcl_SetCommandTokenInfo to change + * the command procedure or client data for the command being evaluated, + * and these changes will take effect with the current evaluation. + * + * The 'level' argument specifies the maximum nesting level of calls to + * be traced. If the execution depth of the interpreter exceeds 'level', + * the trace callback is not executed. + * + * The 'flags' argument is either zero or the value, + * TCL_ALLOW_INLINE_COMPILATION. If the TCL_ALLOW_INLINE_COMPILATION flag + * is not present, the bytecode compiler will not generate inline code + * for Tcl's built-in commands. This behavior will have a significant + * impact on performance, but will ensure that all command evaluations + * are traced. If the TCL_ALLOW_INLINE_COMPILATION flag is present, the + * bytecode compiler will have its normal behavior of compiling in-line + * code for some of Tcl's built-in commands. In this case, the tracing + * will be imprecise - in-line code will not be traced - but run-time + * performance will be improved. The latter behavior is desired for many + * applications such as profiling of run time. + * + * When the trace is deleted, the 'delProc' function will be invoked, + * passing it the original client data. * *---------------------------------------------------------------------- */ Tcl_Trace -Tcl_CreateObjTrace( interp, level, flags, proc, clientData, delProc ) +Tcl_CreateObjTrace(interp, level, flags, proc, clientData, delProc) Tcl_Interp* interp; /* Tcl interpreter */ int level; /* Maximum nesting level */ int flags; /* Flags, see above */ Tcl_CmdObjTraceProc* proc; /* Trace callback */ ClientData clientData; /* Client data for the callback */ Tcl_CmdObjTraceDeleteProc* delProc; - /* Procedure to call when trace is deleted */ + /* Function to call when trace is deleted */ { register Trace *tracePtr; register Interp *iPtr = (Interp *) interp; - /* Test if this trace allows inline compilation of commands */ + /* + * Test if this trace allows inline compilation of commands. + */ if (!(flags & TCL_ALLOW_INLINE_COMPILATION)) { if (iPtr->tracesForbiddingInline == 0) { - /* - * When the first trace forbidding inline compilation is - * created, invalidate existing compiled code for this - * interpreter and arrange (by setting the - * DONT_COMPILE_CMDS_INLINE flag) that when compiling new - * code, no commands will be compiled inline (i.e., into - * an inline sequence of instructions). We do this because - * commands that were compiled inline will never result in + * When the first trace forbidding inline compilation is created, + * invalidate existing compiled code for this interpreter and + * arrange (by setting the DONT_COMPILE_CMDS_INLINE flag) that + * when compiling new code, no commands will be compiled inline + * (i.e., into an inline sequence of instructions). We do this + * because commands that were compiled inline will never result in * a command trace being called. */ @@ -2051,15 +2094,15 @@ Tcl_CreateObjTrace( interp, level, flags, proc, clientData, delProc ) } iPtr->tracesForbiddingInline++; } - + tracePtr = (Trace *) ckalloc(sizeof(Trace)); - tracePtr->level = level; - tracePtr->proc = proc; - tracePtr->clientData = clientData; - tracePtr->delProc = delProc; - tracePtr->nextPtr = iPtr->tracePtr; - tracePtr->flags = flags; - iPtr->tracePtr = tracePtr; + tracePtr->level = level; + tracePtr->proc = proc; + tracePtr->clientData = clientData; + tracePtr->delProc = delProc; + tracePtr->nextPtr = iPtr->tracePtr; + tracePtr->flags = flags; + iPtr->tracePtr = tracePtr; return (Tcl_Trace) tracePtr; } @@ -2069,16 +2112,16 @@ Tcl_CreateObjTrace( interp, level, flags, proc, clientData, delProc ) * * Tcl_CreateTrace -- * - * Arrange for a procedure to be called to trace command execution. + * Arrange for a function to be called to trace command execution. * * Results: - * The return value is a token for the trace, which may be passed - * to Tcl_DeleteTrace to eliminate the trace. + * The return value is a token for the trace, which may be passed to + * Tcl_DeleteTrace to eliminate the trace. * * Side effects: - * From now on, proc will be called just before a command procedure - * is called to execute a Tcl command. Calls to proc will have the - * following form: + * From now on, proc will be called just before a command procedure is + * called to execute a Tcl command. Calls to proc will have the following + * form: * * void * proc(clientData, interp, level, command, cmdProc, cmdClientData, @@ -2094,15 +2137,14 @@ Tcl_CreateObjTrace( interp, level, flags, proc, clientData, delProc ) * { * } * - * The clientData and interp arguments to proc will be the same - * as the corresponding arguments to this procedure. Level gives - * the nesting level of command interpretation for this interpreter - * (0 corresponds to top level). Command gives the ASCII text of - * the raw command, cmdProc and cmdClientData give the procedure that - * will be called to process the command and the ClientData value it - * will receive, and argc and argv give the arguments to the - * command, after any argument parsing and substitution. Proc - * does not return a value. + * The clientData and interp arguments to proc will be the same as the + * corresponding arguments to this function. Level gives the nesting + * level of command interpretation for this interpreter (0 corresponds to + * top level). Command gives the ASCII text of the raw command, cmdProc + * and cmdClientData give the function that will be called to process the + * command and the ClientData value it will receive, and argc and argv + * give the arguments to the command, after any argument parsing and + * substitution. Proc does not return a value. * *---------------------------------------------------------------------- */ @@ -2112,16 +2154,16 @@ Tcl_CreateTrace(interp, level, proc, clientData) Tcl_Interp *interp; /* Interpreter in which to create trace. */ int level; /* Only call proc for commands at nesting * level<=argument level (1=>top level). */ - Tcl_CmdTraceProc *proc; /* Procedure to call before executing each + Tcl_CmdTraceProc *proc; /* Function to call before executing each * command. */ ClientData clientData; /* Arbitrary value word to pass to proc. */ { StringTraceData* data; - data = (StringTraceData*) ckalloc( sizeof( *data )); + data = (StringTraceData *) ckalloc(sizeof(*data)); data->clientData = clientData; data->proc = proc; - return Tcl_CreateObjTrace( interp, level, 0, StringTraceProc, - (ClientData) data, StringTraceDeleteProc ); + return Tcl_CreateObjTrace(interp, level, 0, StringTraceProc, + (ClientData) data, StringTraceDeleteProc); } /* @@ -2129,20 +2171,19 @@ Tcl_CreateTrace(interp, level, proc, clientData) * * StringTraceProc -- * - * Invoke a string-based trace procedure from an object-based - * callback. + * Invoke a string-based trace function from an object-based callback. * * Results: * None. * * Side effects: - * Whatever the string-based trace procedure does. + * Whatever the string-based trace function does. * *---------------------------------------------------------------------- */ static int -StringTraceProc( clientData, interp, level, command, commandInfo, objc, objv ) +StringTraceProc(clientData, interp, level, command, commandInfo, objc, objv) ClientData clientData; Tcl_Interp* interp; int level; @@ -2153,33 +2194,30 @@ StringTraceProc( clientData, interp, level, command, commandInfo, objc, objv ) { StringTraceData* data = (StringTraceData*) clientData; Command* cmdPtr = (Command*) commandInfo; - CONST char** argv; /* Args to pass to string trace proc */ - int i; /* - * This is a bit messy because we have to emulate the old trace - * interface, which uses strings for everything. + * This is a bit messy because we have to emulate the old trace interface, + * which uses strings for everything. */ - - argv = (CONST char **) ckalloc((unsigned) ( (objc + 1) - * sizeof(CONST char *) )); + + argv = (CONST char **) + ckalloc((unsigned) ((objc + 1) * sizeof(CONST char *))); for (i = 0; i < objc; i++) { argv[i] = Tcl_GetString(objv[i]); } argv[objc] = 0; /* - * Invoke the command procedure. Note that we cast away const-ness - * on two parameters for compatibility with legacy code; the code - * MUST NOT modify either command or argv. + * Invoke the command function. Note that we cast away const-ness on two + * parameters for compatibility with legacy code; the code MUST NOT modify + * either command or argv. */ - - ( data->proc )( data->clientData, interp, level, - (char*) command, cmdPtr->proc, cmdPtr->clientData, - objc, argv ); - ckfree( (char*) argv ); + + (data->proc)(data->clientData, interp, level, (char *) command, + cmdPtr->proc, cmdPtr->clientData, objc, argv); + ckfree((char *) argv); return TCL_OK; } @@ -2201,10 +2239,10 @@ StringTraceProc( clientData, interp, level, command, commandInfo, objc, objv ) */ static void -StringTraceDeleteProc( clientData ) +StringTraceDeleteProc(clientData) ClientData clientData; { - ckfree( (char*) clientData ); + ckfree((char *) clientData); } /* @@ -2218,8 +2256,8 @@ StringTraceDeleteProc( clientData ) * None. * * Side effects: - * From now on there will be no more calls to the procedure given - * in trace. + * From now on there will be no more calls to the function given in + * trace. * *---------------------------------------------------------------------- */ @@ -2236,8 +2274,8 @@ Tcl_DeleteTrace(interp, trace) ActiveInterpTrace *activePtr; /* - * Locate the trace entry in the interpreter's trace list, - * and remove it from the list. + * Locate the trace entry in the interpreter's trace list, and remove it + * from the list. */ prevPtr = NULL; @@ -2251,9 +2289,9 @@ Tcl_DeleteTrace(interp, trace) (*tracePtr2) = (*tracePtr2)->nextPtr; /* - * The code below makes it possible to delete traces while traces - * are active: it makes sure that the deleted trace won't be - * processed by TclCheckInterpTraces. + * The code below makes it possible to delete traces while traces are + * active: it makes sure that the deleted trace won't be processed by + * TclCheckInterpTraces. */ for (activePtr = iPtr->activeInterpTracePtr; activePtr != NULL; @@ -2269,9 +2307,9 @@ Tcl_DeleteTrace(interp, trace) /* * If the trace forbids bytecode compilation, change the interpreter's - * state. If bytecode compilation is now permitted, flag the fact and - * advance the compilation epoch so that procs will be recompiled to - * take advantage of it. + * state. If bytecode compilation is now permitted, flag the fact and + * advance the compilation epoch so that procs will be recompiled to take + * advantage of it. */ if (!(tracePtr->flags & TCL_ALLOW_INLINE_COMPILATION)) { @@ -2290,7 +2328,9 @@ Tcl_DeleteTrace(interp, trace) (tracePtr->delProc)(tracePtr->clientData); } - /* Delete the trace object */ + /* + * Delete the trace object. + */ Tcl_EventuallyFree((char*)tracePtr, TCL_DYNAMIC); } @@ -2300,9 +2340,9 @@ Tcl_DeleteTrace(interp, trace) * * TclTraceVarExists -- * - * This is called from info exists. We need to trigger read - * and/or array traces because they may end up creating a - * variable that doesn't currently exist. + * This is called from info exists. We need to trigger read and/or array + * traces because they may end up creating a variable that doesn't + * currently exist. * * Results: * A pointer to the Var structure, or NULL. @@ -2322,17 +2362,16 @@ TclVarTraceExists(interp, varName) Var *arrayPtr; /* - * The choice of "create" flag values is delicate here, and - * matches the semantics of GetVar. Things are still not perfect, - * however, because if you do "info exists x" you get a varPtr - * and therefore trigger traces. However, if you do - * "info exists x(i)", then you only get a varPtr if x is already - * known to be an array. Otherwise you get NULL, and no trace - * is triggered. This matches Tcl 7.6 semantics. + * The choice of "create" flag values is delicate here, and matches the + * semantics of GetVar. Things are still not perfect, however, because if + * you do "info exists x" you get a varPtr and therefore trigger traces. + * However, if you do "info exists x(i)", then you only get a varPtr if x + * is already known to be an array. Otherwise you get NULL, and no trace + * is triggered. This matches Tcl 7.6 semantics. */ - varPtr = TclLookupVar(interp, varName, (char *) NULL, - 0, "access", /*createPart1*/ 0, /*createPart2*/ 1, &arrayPtr); + varPtr = TclLookupVar(interp, varName, (char *) NULL, 0, "access", + /*createPart1*/ 0, /*createPart2*/ 1, &arrayPtr); if (varPtr == NULL) { return NULL; @@ -2345,8 +2384,8 @@ TclVarTraceExists(interp, varName) } /* - * If the variable doesn't exist anymore and no-one's using - * it, then free up the relevant structures and hash table entries. + * If the variable doesn't exist anymore and no-one's using it, then free + * up the relevant structures and hash table entries. */ if (TclIsVarUndefined(varPtr)) { @@ -2362,21 +2401,20 @@ TclVarTraceExists(interp, varName) * * TclCallVarTraces -- * - * This procedure is invoked to find and invoke relevant - * trace procedures associated with a particular operation on - * a variable. This procedure invokes traces both on the - * variable and on its containing array (where relevant). + * This function is invoked to find and invoke relevant trace functions + * associated with a particular operation on a variable. This function + * invokes traces both on the variable and on its containing array (where + * relevant). * * Results: - * Returns TCL_OK to indicate normal operation. Returns TCL_ERROR - * if invocation of a trace procedure indicated an error. When - * TCL_ERROR is returned and leaveErrMsg is true, then the - * errorInfo field of iPtr has information about the error - * placed in it. + * Returns TCL_OK to indicate normal operation. Returns TCL_ERROR if + * invocation of a trace function indicated an error. When TCL_ERROR is + * returned and leaveErrMsg is true, then the errorInfo field of iPtr has + * information about the error placed in it. * * Side effects: - * Almost anything can happen, depending on trace; this procedure - * itself doesn't have any side effects. + * Almost anything can happen, depending on trace; this function itself + * doesn't have any side effects. * *---------------------------------------------------------------------- */ @@ -2384,21 +2422,20 @@ TclVarTraceExists(interp, varName) int TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) Interp *iPtr; /* Interpreter containing variable. */ - register Var *arrayPtr; /* Pointer to array variable that contains - * the variable, or NULL if the variable - * isn't an element of an array. */ - Var *varPtr; /* Variable whose traces are to be - * invoked. */ + register Var *arrayPtr; /* Pointer to array variable that contains the + * variable, or NULL if the variable isn't an + * element of an array. */ + Var *varPtr; /* Variable whose traces are to be invoked. */ CONST char *part1; CONST char *part2; /* Variable's two-part name. */ - int flags; /* Flags passed to trace procedures: - * indicates what's happening to variable, - * plus other stuff like TCL_GLOBAL_ONLY, + int flags; /* Flags passed to trace functions: indicates + * what's happening to variable, plus other + * stuff like TCL_GLOBAL_ONLY, * TCL_NAMESPACE_ONLY, and * TCL_INTERP_DESTROYED. */ - int leaveErrMsg; /* If true, and one of the traces indicates an - * error, then leave an error message and stack - * trace information in *iPTr. */ + int leaveErrMsg; /* If true, and one of the traces indicates an + * error, then leave an error message and + * stack trace information in *iPTr. */ { register VarTrace *tracePtr; ActiveVarTrace active; @@ -2411,8 +2448,8 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) Tcl_InterpState state = NULL; /* - * If there are already similar trace procedures active for the - * variable, don't call them again. + * If there are already similar trace functions active for the variable, + * don't call them again. */ if (TclIsVarTraceActive(varPtr)) { @@ -2425,12 +2462,11 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) } /* - * If the variable name hasn't been parsed into array name and - * element, do it here. If there really is an array element, - * make a copy of the original name so that NULLs can be - * inserted into it to separate the names (can't modify the name - * string in place, because the string might get used by the - * callbacks we invoke). + * If the variable name hasn't been parsed into array name and element, do + * it here. If there really is an array element, make a copy of the + * original name so that NULLs can be inserted into it to separate the + * names (can't modify the name string in place, because the string might + * get used by the callbacks we invoke). */ copiedName = 0; @@ -2445,6 +2481,7 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) if (*p == ')') { int offset = (openParen - part1); char *newPart1; + Tcl_DStringInit(&nameCopy); Tcl_DStringAppend(&nameCopy, part1, (p-part1)); newPart1 = Tcl_DStringValue(&nameCopy); @@ -2469,7 +2506,7 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) if (arrayPtr != NULL && !TclIsVarTraceActive(arrayPtr)) { active.varPtr = arrayPtr; for (tracePtr = arrayPtr->tracePtr; tracePtr != NULL; - tracePtr = active.nextTracePtr) { + tracePtr = active.nextTracePtr) { active.nextTracePtr = tracePtr->nextPtr; if (!(tracePtr->flags & flags)) { continue; @@ -2482,10 +2519,13 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) (Tcl_Interp *) iPtr, part1, part2, flags); if (result != NULL) { if (flags & TCL_TRACE_UNSETS) { - /* Ignore errors in unset traces */ + /* + * Ignore errors in unset traces. + */ + DisposeTraceResult(tracePtr->flags, result); } else { - disposeFlags = tracePtr->flags; + disposeFlags = tracePtr->flags; code = TCL_ERROR; } } @@ -2505,7 +2545,7 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) } active.varPtr = varPtr; for (tracePtr = varPtr->tracePtr; tracePtr != NULL; - tracePtr = active.nextTracePtr) { + tracePtr = active.nextTracePtr) { active.nextTracePtr = tracePtr->nextPtr; if (!(tracePtr->flags & flags)) { continue; @@ -2518,7 +2558,10 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) (Tcl_Interp *) iPtr, part1, part2, flags); if (result != NULL) { if (flags & TCL_TRACE_UNSETS) { - /* Ignore errors in unset traces */ + /* + * Ignore errors in unset traces. + */ + DisposeTraceResult(tracePtr->flags, result); } else { disposeFlags = tracePtr->flags; @@ -2532,11 +2575,11 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) } /* - * Restore the variable's flags, remove the record of our active - * traces, and then return. + * Restore the variable's flags, remove the record of our active traces, + * and then return. */ - done: + done: if (code == TCL_ERROR) { if (leaveErrMsg) { CONST char *type = ""; @@ -2555,18 +2598,18 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) } Tcl_AppendToObj(errorInfo, "\n (", -1); switch (flags&(TCL_TRACE_READS|TCL_TRACE_WRITES|TCL_TRACE_ARRAY)) { - case TCL_TRACE_READS: - type = "read"; - Tcl_AppendToObj(errorInfo, type, -1); - break; - case TCL_TRACE_WRITES: - type = "set"; - Tcl_AppendToObj(errorInfo, "write", -1); - break; - case TCL_TRACE_ARRAY: - type = "trace array"; - Tcl_AppendToObj(errorInfo, "array", -1); - break; + case TCL_TRACE_READS: + type = "read"; + Tcl_AppendToObj(errorInfo, type, -1); + break; + case TCL_TRACE_WRITES: + type = "set"; + Tcl_AppendToObj(errorInfo, "write", -1); + break; + case TCL_TRACE_ARRAY: + type = "trace array"; + Tcl_AppendToObj(errorInfo, "array", -1); + break; } if (disposeFlags & TCL_TRACE_RESULT_OBJECT) { TclVarErrMsg((Tcl_Interp *) iPtr, part1, part2, type, @@ -2618,9 +2661,9 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) * * DisposeTraceResult-- * - * This procedure is called to dispose of the result returned from - * a trace procedure. The disposal method appropriate to the type - * of result is determined by flags. + * This function is called to dispose of the result returned from a trace + * function. The disposal method appropriate to the type of result is + * determined by flags. * * Results: * None. @@ -2634,9 +2677,9 @@ TclCallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg) static void DisposeTraceResult(flags, result) int flags; /* Indicates type of result to determine - * proper disposal method */ - char *result; /* The result returned from a trace - * procedure to be disposed */ + * proper disposal method. */ + char *result; /* The result returned from a trace function + * to be disposed. */ { if (flags & TCL_TRACE_RESULT_DYNAMIC) { ckfree(result); @@ -2656,9 +2699,8 @@ DisposeTraceResult(flags, result) * None. * * Side effects: - * If there exists a trace for the variable given by varName - * with the given flags, proc, and clientData, then that trace - * is removed. + * If there exists a trace for the variable given by varName with the + * given flags, proc, and clientData, then that trace is removed. * *---------------------------------------------------------------------- */ @@ -2666,14 +2708,13 @@ DisposeTraceResult(flags, result) void Tcl_UntraceVar(interp, varName, flags, proc, clientData) Tcl_Interp *interp; /* Interpreter containing variable. */ - CONST char *varName; /* Name of variable; may end with "(index)" - * to signify an array reference. */ - int flags; /* OR-ed collection of bits describing - * current trace, including any of - * TCL_TRACE_READS, TCL_TRACE_WRITES, - * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY - * and TCL_NAMESPACE_ONLY. */ - Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */ + CONST char *varName; /* Name of variable; may end with "(index)" to + * signify an array reference. */ + int flags; /* OR-ed collection of bits describing current + * trace, including any of TCL_TRACE_READS, + * TCL_TRACE_WRITES, TCL_TRACE_UNSETS, + * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY. */ + Tcl_VarTraceProc *proc; /* Function assocated with trace. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { Tcl_UntraceVar2(interp, varName, (char *) NULL, flags, proc, clientData); @@ -2690,9 +2731,8 @@ Tcl_UntraceVar(interp, varName, flags, proc, clientData) * None. * * Side effects: - * If there exists a trace for the variable given by part1 - * and part2 with the given flags, proc, and clientData, then - * that trace is removed. + * If there exists a trace for the variable given by part1 and part2 with + * the given flags, proc, and clientData, then that trace is removed. * *---------------------------------------------------------------------- */ @@ -2701,15 +2741,14 @@ void Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) Tcl_Interp *interp; /* Interpreter containing variable. */ CONST char *part1; /* Name of variable or array. */ - CONST char *part2; /* Name of element within array; NULL means + CONST char *part2; /* Name of element within array; NULL means * trace applies to scalar variable or array * as-a-whole. */ - int flags; /* OR-ed collection of bits describing - * current trace, including any of - * TCL_TRACE_READS, TCL_TRACE_WRITES, - * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, - * and TCL_NAMESPACE_ONLY. */ - Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */ + int flags; /* OR-ed collection of bits describing current + * trace, including any of TCL_TRACE_READS, + * TCL_TRACE_WRITES, TCL_TRACE_UNSETS, + * TCL_GLOBAL_ONLY, and TCL_NAMESPACE_ONLY. */ + Tcl_VarTraceProc *proc; /* Function assocated with trace. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { register VarTrace *tracePtr; @@ -2718,11 +2757,12 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) Interp *iPtr = (Interp *) interp; ActiveVarTrace *activePtr; int flagMask; - + /* * Set up a mask to mask out the parts of the flags that we are not * interested in now. */ + flagMask = TCL_GLOBAL_ONLY | TCL_NAMESPACE_ONLY; varPtr = TclLookupVar(interp, part1, part2, flags & flagMask, /*msg*/ (char *) NULL, @@ -2735,14 +2775,15 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) * Set up a mask to mask out the parts of the flags that we are not * interested in now. */ + flagMask = TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS | - TCL_TRACE_ARRAY | TCL_TRACE_RESULT_DYNAMIC | TCL_TRACE_RESULT_OBJECT; + TCL_TRACE_ARRAY | TCL_TRACE_RESULT_DYNAMIC | TCL_TRACE_RESULT_OBJECT; #ifndef TCL_REMOVE_OBSOLETE_TRACES flagMask |= TCL_TRACE_OLD_STYLE; #endif flags &= flagMask; - for (tracePtr = varPtr->tracePtr, prevPtr = NULL; ; - prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { + for (tracePtr = varPtr->tracePtr, prevPtr = NULL; ; + prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) { if (tracePtr == NULL) { return; } @@ -2753,13 +2794,13 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) } /* - * The code below makes it possible to delete traces while traces - * are active: it makes sure that the deleted trace won't be - * processed by TclCallVarTraces. + * The code below makes it possible to delete traces while traces are + * active: it makes sure that the deleted trace won't be processed by + * TclCallVarTraces. */ for (activePtr = iPtr->activeVarTracePtr; activePtr != NULL; - activePtr = activePtr->nextPtr) { + activePtr = activePtr->nextPtr) { if (activePtr->nextTracePtr == tracePtr) { activePtr->nextTracePtr = tracePtr->nextPtr; } @@ -2772,8 +2813,8 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) Tcl_EventuallyFree((ClientData) tracePtr, TCL_DYNAMIC); /* - * If this is the last trace on the variable, and the variable is - * unset and unused, then free up the variable. + * If this is the last trace on the variable, and the variable is unset + * and unused, then free up the variable. */ if (TclIsVarUndefined(varPtr)) { @@ -2786,20 +2827,17 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) * * Tcl_VarTraceInfo -- * - * Return the clientData value associated with a trace on a - * variable. This procedure can also be used to step through - * all of the traces on a particular variable that have the - * same trace procedure. + * Return the clientData value associated with a trace on a variable. + * This function can also be used to step through all of the traces on a + * particular variable that have the same trace function. * * Results: - * The return value is the clientData value associated with - * a trace on the given variable. Information will only be - * returned for a trace with proc as trace procedure. If - * the clientData argument is NULL then the first such trace is - * returned; otherwise, the next relevant one after the one - * given by clientData will be returned. If the variable - * doesn't exist, or if there are no (more) traces for it, - * then NULL is returned. + * The return value is the clientData value associated with a trace on + * the given variable. Information will only be returned for a trace with + * proc as trace function. If the clientData argument is NULL then the + * first such trace is returned; otherwise, the next relevant one after + * the one given by clientData will be returned. If the variable doesn't + * exist, or if there are no (more) traces for it, then NULL is returned. * * Side effects: * None. @@ -2810,16 +2848,15 @@ Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) ClientData Tcl_VarTraceInfo(interp, varName, flags, proc, prevClientData) Tcl_Interp *interp; /* Interpreter containing variable. */ - CONST char *varName; /* Name of variable; may end with "(index)" - * to signify an array reference. */ + CONST char *varName; /* Name of variable; may end with "(index)" to + * signify an array reference. */ int flags; /* OR-ed combo or TCL_GLOBAL_ONLY, * TCL_NAMESPACE_ONLY (can be 0). */ - Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */ - ClientData prevClientData; /* If non-NULL, gives last value returned - * by this procedure, so this call will - * return the next trace after that one. - * If NULL, this call will return the - * first trace. */ + Tcl_VarTraceProc *proc; /* Function assocated with trace. */ + ClientData prevClientData; /* If non-NULL, gives last value returned by + * this function, so this call will return the + * next trace after that one. If NULL, this + * call will return the first trace. */ { return Tcl_VarTraceInfo2(interp, varName, (char *) NULL, flags, proc, prevClientData); @@ -2830,8 +2867,8 @@ Tcl_VarTraceInfo(interp, varName, flags, proc, prevClientData) * * Tcl_VarTraceInfo2 -- * - * Same as Tcl_VarTraceInfo, except takes name in two pieces - * instead of one. + * Same as Tcl_VarTraceInfo, except takes name in two pieces instead of + * one. * * Results: * Same as Tcl_VarTraceInfo. @@ -2846,17 +2883,16 @@ ClientData Tcl_VarTraceInfo2(interp, part1, part2, flags, proc, prevClientData) Tcl_Interp *interp; /* Interpreter containing variable. */ CONST char *part1; /* Name of variable or array. */ - CONST char *part2; /* Name of element within array; NULL means + CONST char *part2; /* Name of element within array; NULL means * trace applies to scalar variable or array * as-a-whole. */ int flags; /* OR-ed combination of TCL_GLOBAL_ONLY, * TCL_NAMESPACE_ONLY. */ - Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */ - ClientData prevClientData; /* If non-NULL, gives last value returned - * by this procedure, so this call will - * return the next trace after that one. - * If NULL, this call will return the - * first trace. */ + Tcl_VarTraceProc *proc; /* Function assocated with trace. */ + ClientData prevClientData; /* If non-NULL, gives last value returned by + * this function, so this call will return the + * next trace after that one. If NULL, this + * call will return the first trace. */ { register VarTrace *tracePtr; Var *varPtr, *arrayPtr; @@ -2883,7 +2919,7 @@ Tcl_VarTraceInfo2(interp, part1, part2, flags, proc, prevClientData) } } } - for ( ; tracePtr != NULL; tracePtr = tracePtr->nextPtr) { + for (; tracePtr!=NULL ; tracePtr=tracePtr->nextPtr) { if (tracePtr->traceProc == proc) { return tracePtr->clientData; } @@ -2896,37 +2932,36 @@ Tcl_VarTraceInfo2(interp, part1, part2, flags, proc, prevClientData) * * Tcl_TraceVar -- * - * Arrange for reads and/or writes to a variable to cause a - * procedure to be invoked, which can monitor the operations - * and/or change their actions. + * Arrange for reads and/or writes to a variable to cause a function to + * be invoked, which can monitor the operations and/or change their + * actions. * * Results: * A standard Tcl return value. * * Side effects: - * A trace is set up on the variable given by varName, such that - * future references to the variable will be intermediated by - * proc. See the manual entry for complete details on the calling - * sequence for proc. + * A trace is set up on the variable given by varName, such that future + * references to the variable will be intermediated by proc. See the + * manual entry for complete details on the calling sequence for proc. * *---------------------------------------------------------------------- */ int Tcl_TraceVar(interp, varName, flags, proc, clientData) - Tcl_Interp *interp; /* Interpreter in which variable is - * to be traced. */ - CONST char *varName; /* Name of variable; may end with "(index)" - * to signify an array reference. */ - int flags; /* OR-ed collection of bits, including any - * of TCL_TRACE_READS, TCL_TRACE_WRITES, + Tcl_Interp *interp; /* Interpreter in which variable is to be + * traced. */ + CONST char *varName; /* Name of variable; may end with "(index)" to + * signify an array reference. */ + int flags; /* OR-ed collection of bits, including any of + * TCL_TRACE_READS, TCL_TRACE_WRITES, * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, and * TCL_NAMESPACE_ONLY. */ - Tcl_VarTraceProc *proc; /* Procedure to call when specified ops are + Tcl_VarTraceProc *proc; /* Function to call when specified ops are * invoked upon varName. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { - return Tcl_TraceVar2(interp, varName, (char *) NULL, + return Tcl_TraceVar2(interp, varName, (char *) NULL, flags, proc, clientData); } @@ -2935,48 +2970,49 @@ Tcl_TraceVar(interp, varName, flags, proc, clientData) * * Tcl_TraceVar2 -- * - * Arrange for reads and/or writes to a variable to cause a - * procedure to be invoked, which can monitor the operations - * and/or change their actions. + * Arrange for reads and/or writes to a variable to cause a function to + * be invoked, which can monitor the operations and/or change their + * actions. * * Results: * A standard Tcl return value. * * Side effects: - * A trace is set up on the variable given by part1 and part2, such - * that future references to the variable will be intermediated by - * proc. See the manual entry for complete details on the calling - * sequence for proc. + * A trace is set up on the variable given by part1 and part2, such that + * future references to the variable will be intermediated by proc. See + * the manual entry for complete details on the calling sequence for + * proc. * *---------------------------------------------------------------------- */ int Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData) - Tcl_Interp *interp; /* Interpreter in which variable is - * to be traced. */ + Tcl_Interp *interp; /* Interpreter in which variable is to be + * traced. */ CONST char *part1; /* Name of scalar variable or array. */ - CONST char *part2; /* Name of element within array; NULL means + CONST char *part2; /* Name of element within array; NULL means * trace applies to scalar variable or array * as-a-whole. */ - int flags; /* OR-ed collection of bits, including any - * of TCL_TRACE_READS, TCL_TRACE_WRITES, - * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, - * and TCL_NAMESPACE_ONLY. */ - Tcl_VarTraceProc *proc; /* Procedure to call when specified ops are + int flags; /* OR-ed collection of bits, including any of + * TCL_TRACE_READS, TCL_TRACE_WRITES, + * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, and + * TCL_NAMESPACE_ONLY. */ + Tcl_VarTraceProc *proc; /* Function to call when specified ops are * invoked upon varName. */ ClientData clientData; /* Arbitrary argument to pass to proc. */ { Var *varPtr, *arrayPtr; register VarTrace *tracePtr; int flagMask; - - /* + + /* * We strip 'flags' down to just the parts which are relevant to - * TclLookupVar, to avoid conflicts between trace flags and - * internal namespace flags such as 'TCL_FIND_ONLY_NS'. This can - * now occur since we have trace flags with values 0x1000 and higher. + * TclLookupVar, to avoid conflicts between trace flags and internal + * namespace flags such as 'TCL_FIND_ONLY_NS'. This can now occur since we + * have trace flags with values 0x1000 and higher. */ + flagMask = TCL_GLOBAL_ONLY | TCL_NAMESPACE_ONLY; varPtr = TclLookupVar(interp, part1, part2, (flags & flagMask) | TCL_LEAVE_ERR_MSG, @@ -2986,10 +3022,10 @@ Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData) } /* - * Check for a nonsense flag combination. Note that this is a - * Tcl_Panic() because there should be no code path that ever sets - * both flags. + * Check for a nonsense flag combination. Note that this is a Tcl_Panic() + * because there should be no code path that ever sets both flags. */ + if ((flags&TCL_TRACE_RESULT_DYNAMIC) && (flags&TCL_TRACE_RESULT_OBJECT)) { Tcl_Panic("bad result flag combination"); } @@ -2998,16 +3034,25 @@ Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData) * Set up trace information. */ - flagMask = TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS | - TCL_TRACE_ARRAY | TCL_TRACE_RESULT_DYNAMIC | TCL_TRACE_RESULT_OBJECT; + flagMask = TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS | + TCL_TRACE_ARRAY | TCL_TRACE_RESULT_DYNAMIC | TCL_TRACE_RESULT_OBJECT; #ifndef TCL_REMOVE_OBSOLETE_TRACES flagMask |= TCL_TRACE_OLD_STYLE; #endif tracePtr = (VarTrace *) ckalloc(sizeof(VarTrace)); - tracePtr->traceProc = proc; - tracePtr->clientData = clientData; - tracePtr->flags = flags & flagMask; - tracePtr->nextPtr = varPtr->tracePtr; - varPtr->tracePtr = tracePtr; + tracePtr->traceProc = proc; + tracePtr->clientData = clientData; + tracePtr->flags = flags & flagMask; + tracePtr->nextPtr = varPtr->tracePtr; + + varPtr->tracePtr = tracePtr; return TCL_OK; } + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |