Provided by: tcl8.6-doc_8.6.9+dfsg-2_all bug

NAME

       trace - Monitor variable accesses, command usages and command executions

SYNOPSIS

       trace option ?arg arg ...?
_________________________________________________________________________________________________

DESCRIPTION

       This  command  causes Tcl commands to be executed whenever certain operations are invoked.
       The legal options (which may be abbreviated) are:

       trace add type name ops ?args?
              Where type is command, execution, or variable.

              trace add command name ops commandPrefix
                     Arrange  for  commandPrefix  to  be  executed  (with  additional  arguments)
                     whenever  command name is modified in one of the ways given by the list ops.
                     Name will be resolved using the usual namespace  resolution  rules  used  by
                     commands. If the command does not exist, an error will be thrown.

                     Ops indicates which operations are of interest, and is a list of one or more
                     of the following items:

                     rename Invoke commandPrefix whenever the traced command  is  renamed.   Note
                            that  renaming  to  the empty string is considered deletion, and will
                            not be traced with “rename”.

                     delete Invoke commandPrefix when the traced command is deleted. Commands can
                            be  deleted  explicitly  by  using  the  rename command to rename the
                            command to an empty  string.  Commands  are  also  deleted  when  the
                            interpreter  is deleted, but traces will not be invoked because there
                            is no interpreter in which to execute them.

                     When the trace triggers, depending on the operations being traced, a  number
                     of  arguments are appended to commandPrefix so that the actual command is as
                     follows:

                            commandPrefix oldName newName op

                     OldName and newName give the traced command's current (old)  name,  and  the
                     name  to  which  it is being renamed (the empty string if this is a “delete”
                     operation).  Op indicates what operation is being performed on the  command,
                     and is one of rename or delete as defined above.  The trace operation cannot
                     be used to stop a command from being deleted.  Tcl will  always  remove  the
                     command once the trace is complete.  Recursive renaming or deleting will not
                     cause further traces of the same type to be evaluated,  so  a  delete  trace
                     which itself deletes the command, or a rename trace which itself renames the
                     command will not cause further trace evaluations to occur.  Both oldName and
                     newName are fully qualified with any namespace(s) in which they appear.

              trace add execution name ops commandPrefix
                     Arrange  for  commandPrefix  to  be  executed  (with  additional  arguments)
                     whenever command name is executed,  with  traces  occurring  at  the  points
                     indicated  by the list ops.  Name will be resolved using the usual namespace
                     resolution rules used by commands.  If the command does not exist, an  error
                     will be thrown.

                     Ops indicates which operations are of interest, and is a list of one or more
                     of the following items:

                     enter  Invoke commandPrefix whenever the  command  name  is  executed,  just
                            before the actual execution takes place.

                     leave  Invoke  commandPrefix  whenever  the  command  name is executed, just
                            after the actual execution takes place.

                     enterstep
                            Invoke commandPrefix for every Tcl command which is executed from the
                            start  of  the  execution  of the procedure name until that procedure
                            finishes. CommandPrefix is invoked just before the  actual  execution
                            of  the  Tcl  command  being reported takes place.  For example if we
                            have “proc foo {} { puts "hello" }”, then an enterstep trace would be
                            invoked just before “puts "hello"” is executed.  Setting an enterstep
                            trace on a command name that does not refer to a procedure  will  not
                            result in an error and is simply ignored.

                     leavestep
                            Invoke commandPrefix for every Tcl command which is executed from the
                            start of the execution of the procedure  name  until  that  procedure
                            finishes. CommandPrefix is invoked just after the actual execution of
                            the Tcl command being reported  takes  place.   Setting  a  leavestep
                            trace  on  a command name that does not refer to a procedure will not
                            result in an error and is simply ignored.

                     When the trace triggers, depending on the operations being traced, a  number
                     of  arguments are appended to commandPrefix so that the actual command is as
                     follows:

                     For enter and enterstep operations:

                            commandPrefix command-string op

                     Command-string gives the complete current command being executed (the traced
                     command  for  a  enter  operation,  an  arbitrary  command  for  a enterstep
                     operation), including all  arguments  in  their  fully  expanded  form.   Op
                     indicates what operation is being performed on the command execution, and is
                     one of enter or enterstep as defined above.  The trace operation can be used
                     to stop the command from executing, by deleting the command in question.  Of
                     course when the command is subsequently executed, an “invalid command” error
                     will occur.

                     For leave and leavestep operations:

                            commandPrefix command-string code result op

                     Command-string gives the complete current command being executed (the traced
                     command for  a  enter  operation,  an  arbitrary  command  for  a  enterstep
                     operation),  including  all  arguments  in  their fully expanded form.  Code
                     gives the result code of that execution, and result the result  string.   Op
                     indicates what operation is being performed on the command execution, and is
                     one of leave or leavestep as defined above.  Note that the creation of  many
                     enterstep  or  leavestep  traces  can lead to unintuitive results, since the
                     invoked commands from one trace  can  themselves  lead  to  further  command
                     invocations for other traces.

                     CommandPrefix  executes  in  the  same  context as the code that invoked the
                     traced operation: thus the commandPrefix, if invoked from a procedure,  will
                     have  access  to  the  same  local  variables as code in the procedure. This
                     context may be different than the context in which the trace was created. If
                     commandPrefix  invokes  a  procedure  (which  it  normally  does)  then  the
                     procedure will have to use upvar or uplevel commands if it wishes to  access
                     the local variables of the code which invoked the trace operation.

                     While  commandPrefix  is executing during an execution trace, traces on name
                     are temporarily disabled. This allows the commandPrefix to execute  name  in
                     its  body without invoking any other traces again.  If an error occurs while
                     executing the commandPrefix, then the command name as a  whole  will  return
                     that same error.

                     When  multiple  traces  are  set  on  name,  then  for  enter  and enterstep
                     operations, the traced commands are invoked in the reverse order of how  the
                     traces  were originally created; and for leave and leavestep operations, the
                     traced commands are invoked in the original order of creation.

                     The behavior of execution traces is currently undefined for a  command  name
                     imported into another namespace.

              trace add variable name ops commandPrefix
                     Arrange  for commandPrefix to be executed whenever variable name is accessed
                     in one of the ways given by the list  ops.   Name  may  refer  to  a  normal
                     variable,  an  element of an array, or to an array as a whole (i.e. name may
                     be just the name of an array, with no parenthesized index).  If name  refers
                     to  a whole array, then commandPrefix is invoked whenever any element of the
                     array is manipulated.  If the variable does not exist, it  will  be  created
                     but  will  not  be  given  a value, so it will be visible to namespace which
                     queries, but not to info exists queries.

                     Ops indicates which operations are of interest, and is a list of one or more
                     of the following items:

                     array  Invoke  commandPrefix  whenever  the variable is accessed or modified
                            via the array command, provided that name is not a scalar variable at
                            the  time  that  the  array  command is invoked.  If name is a scalar
                            variable, the access via the  array  command  will  not  trigger  the
                            trace.

                     read   Invoke commandPrefix whenever the variable is read.

                     write  Invoke commandPrefix whenever the variable is written.

                     unset  Invoke  commandPrefix  whenever the variable is unset.  Variables can
                            be unset explicitly  with  the  unset  command,  or  implicitly  when
                            procedures   return   (all  of  their  local  variables  are  unset).
                            Variables are also unset when interpreters are  deleted,  but  traces
                            will  not  be  invoked  because  there  is no interpreter in which to
                            execute them.

                     When the trace triggers, three arguments are appended  to  commandPrefix  so
                     that the actual command is as follows:

                            commandPrefix name1 name2 op

                     Name1  and  name2  give the name(s) for the variable being accessed:  if the
                     variable is a scalar then name1 gives the variable's name and  name2  is  an
                     empty  string; if the variable is an array element then name1 gives the name
                     of the array and name2 gives the index into the array; if an entire array is
                     being deleted and the trace was registered on the overall array, rather than
                     a single element, then name1 gives the array name  and  name2  is  an  empty
                     string.   Name1  and  name2 are not necessarily the same as the name used in
                     the trace variable  command:   the  upvar  command  allows  a  procedure  to
                     reference a variable under a different name.  Op indicates what operation is
                     being performed on the variable, and is one of  read,  write,  or  unset  as
                     defined above.

                     CommandPrefix  executes  in  the  same  context as the code that invoked the
                     traced operation:  if the variable was accessed as part of a Tcl  procedure,
                     then  commandPrefix  will have access to the same local variables as code in
                     the procedure.  This context may be different than the context in which  the
                     trace  was  created. If commandPrefix invokes a procedure (which it normally
                     does) then the procedure will have to use upvar or uplevel if it  wishes  to
                     access the traced variable.  Note also that name1 may not necessarily be the
                     same as the name used to set the trace  on  the  variable;  differences  can
                     occur  if  the  access  is  made  through  a variable defined with the upvar
                     command.

                     For read and write traces, commandPrefix can modify the variable  to  affect
                     the  result of the traced operation.  If commandPrefix modifies the value of
                     a variable during a read or write trace, then the new value will be returned
                     as the result of the traced operation.  The return value from  commandPrefix
                     is ignored except that if it returns an error of any sort  then  the  traced
                     operation  also returns an error with the same error message returned by the
                     trace command (this mechanism can be used to implement read-only  variables,
                     for  example).   For  write  traces,  commandPrefix  is  invoked  after  the
                     variable's value has been changed;  it  can  write  a  new  value  into  the
                     variable  to  override  the original value specified in the write operation.
                     To implement read-only variables, commandPrefix will have to restore the old
                     value of the variable.

                     While commandPrefix is executing during a read or write trace, traces on the
                     variable are temporarily disabled.  This means that reads and writes invoked
                     by commandPrefix will occur directly, without invoking commandPrefix (or any
                     other traces) again.  However, if commandPrefix  unsets  the  variable  then
                     unset traces will be invoked.

                     When  an  unset  trace is invoked, the variable has already been deleted: it
                     will appear to be undefined with no traces.  If an unset occurs because of a
                     procedure  return, then the trace will be invoked in the variable context of
                     the procedure being returned to:  the stack frame of the returning procedure
                     will no longer exist.  Traces are not disabled during unset traces, so if an
                     unset trace command creates a new trace and accesses the variable, the trace
                     will be invoked.  Any errors in unset traces are ignored.

                     If  there  are  multiple  traces  on a variable they are invoked in order of
                     creation, most-recent first.  If one trace returns an error, then no further
                     traces  are  invoked for the variable.  If an array element has a trace set,
                     and there is also a trace set on the array as a  whole,  the  trace  on  the
                     overall array is invoked before the one on the element.

                     Once  created, the trace remains in effect either until the trace is removed
                     with the trace remove variable command described below, until  the  variable
                     is  unset,  or  until  the  interpreter is deleted.  Unsetting an element of
                     array will remove any traces on that element, but will not remove traces  on
                     the overall array.

                     This command returns an empty string.

       trace remove type name opList commandPrefix
              Where type is either command, execution or variable.

              trace remove command name opList commandPrefix
                     If  there  is  a  trace  set on command name with the operations and command
                     given by opList and commandPrefix,  then  the  trace  is  removed,  so  that
                     commandPrefix  will  never  again be invoked.  Returns an empty string.   If
                     name does not exist, the command will throw an error.

              trace remove execution name opList commandPrefix
                     If there is a trace set on command name  with  the  operations  and  command
                     given  by  opList  and  commandPrefix,  then  the  trace is removed, so that
                     commandPrefix will never again be invoked.  Returns an  empty  string.    If
                     name does not exist, the command will throw an error.

              trace remove variable name opList commandPrefix
                     If  there  is  a  trace set on variable name with the operations and command
                     given by opList and commandPrefix,  then  the  trace  is  removed,  so  that
                     commandPrefix will never again be invoked.  Returns an empty string.

       trace info type name
              Where type is either command, execution or variable.

              trace info command name
                     Returns  a  list  containing  one  element  for  each trace currently set on
                     command name. Each element of the list  is  itself  a  list  containing  two
                     elements,  which are the opList and commandPrefix associated with the trace.
                     If name does not have any traces set, then the result of the command will be
                     an empty string.  If name does not exist, the command will throw an error.

              trace info execution name
                     Returns  a  list  containing  one  element  for  each trace currently set on
                     command name. Each element of the list  is  itself  a  list  containing  two
                     elements,  which are the opList and commandPrefix associated with the trace.
                     If name does not have any traces set, then the result of the command will be
                     an empty string.  If name does not exist, the command will throw an error.

              trace info variable name
                     Returns  a  list  containing  one  element  for  each trace currently set on
                     variable name.  Each element of the list is itself  a  list  containing  two
                     elements,  which are the opList and commandPrefix associated with the trace.
                     If name does not exist or does not have any traces set, then the  result  of
                     the command will be an empty string.

       For backwards compatibility, three other subcommands are available:

              trace variable name ops command
                     This is equivalent to trace add variable name ops command.

              trace vdelete name ops command
                     This is equivalent to trace remove variable name ops command

              trace vinfo name
                     This is equivalent to trace info variable name

       These  subcommands  are  deprecated and will likely be removed in a future version of Tcl.
       They use an older syntax in which array, read, write, unset are replaced by a, r, w and  u
       respectively, and the ops argument is not a list, but simply a string concatenation of the
       operations, such as rwua.

EXAMPLES

       Print a message whenever either of the global variables foo and bar are updated,  even  if
       they have a different local name at the time (which can be done with the upvar command):

              proc tracer {varname args} {
                  upvar #0 $varname var
                  puts "$varname was updated to be \"$var\""
              }
              trace add variable foo write "tracer foo"
              trace add variable bar write "tracer bar"

       Ensure that the global variable foobar always contains the product of the global variables
       foo and bar:

              proc doMult args {
                  global foo bar foobar
                  set foobar [expr {$foo * $bar}]
              }
              trace add variable foo write doMult
              trace add variable bar write doMult

       Print a trace of what commands are executed during the processing of a Tcl procedure:

              proc x {} { y }
              proc y {} { z }
              proc z {} { puts hello }
              proc report args {puts [info level 0]}
              trace add execution x enterstep report
              x
                → report y enterstep
                  report z enterstep
                  report {puts hello} enterstep
                  hello

SEE ALSO

       set(3tcl), unset(3tcl)

KEYWORDS

       read, command, rename, variable, write, trace, unset