Unix/Linux Go Back    


OpenDarwin 7.2.1 - man page for trace (opendarwin section n)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


trace(n)			      Tcl Built-In Commands				 trace(n)

_________________________________________________________________________________________________

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 option's (which may be abbreviated) are:

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

	      trace add command name ops command
		     Arrange for command to be executed 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 procedures.   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 command whenever the command is renamed.  Note  that  renaming
			    to	the  empty  string is considered deletion, and will not be traced
			    with 'rename'.

		     delete Invoke command when the 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 inter-
			    preter in which to execute them.

		     When the trace triggers, depending on the operations being traced, a  number
		     of  arguments  are appended to command so that the actual command is as fol-
		     lows:
			    command 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 command
		     Arrange  for command to be executed 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  procedures.  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 command whenever the command name is executed, just before the
			    actual execution takes place.

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

		     enterstep
			    Invoke  command  for  every  tcl command which is executed inside the
			    procedure name, just before the actual execution  takes  place.   For
			    example  if  we have 'proc foo {} { puts "hello" }', then a enterstep
			    trace would be invoked just before puts "hello" is executed.  Setting
			    a  enterstep  trace  on  a command will not result in an error and is
			    simply ignored.

		     leavestep
			    Invoke command for every tcl command which	is  executed  inside  the
			    procedure name, just after the actual execution takes place.  Setting
			    a leavestep trace on a command 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 command so that the actual command is  as  fol-
		     lows:

		     For enter and enterstep operations:
			    command 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  opera-
		     tion),  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:
			    command 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 opera-
		     tion), 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 enter-
		     step 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.

		     Command executes in the same context as the code  that  invoked  the  traced
		     operation:  thus  the command, 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 command
		     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 command is executing during an execution trace,  traces  on	name  are
		     temporarily  disabled.  This  allows the command to execute name in its body
		     without invoking any other traces again.  If an error occurs while executing
		     the  command  body,  then	the command name as a whole will return that same
		     error.

		     When multiple traces are set on name, then for enter  and	enterstep  opera-
		     tions,  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 command
		     Arrange for command 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 command is invoked whenever any element of the array is  manipu-
		     lated.   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 command 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  vari-
			    able, the access via the array command will not trigger the trace.

		     read   Invoke command whenever the variable is read.

		     write  Invoke command whenever the variable is written.

		     unset  Invoke  command  whenever  the  variable  is unset.  Variables can be
			    unset explicitly with the unset command, or  implicitly  when  proce-
			    dures 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 command so that the
		     actual command is as follows:
			    command 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 refer-
		     ence 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.

		     Command 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
		     command will have access to the same local variables as code in  the  proce-
		     dure.  This context may be different than the context in which the trace was
		     created. If command 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, command can modify the	variable  to  affect  the
		     result of the traced operation.  If command 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  command 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 com-
		     mand (this mechanism can be used to implement read-only variables, for exam-
		     ple).   For  write traces, command 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, command will have to restore the old value of the variable.

		     While command is executing during a read or write trace, traces on the vari-
		     able  are temporarily disabled.  This means that reads and writes invoked by
		     command will occur directly, without invoking command (or any other  traces)
		     again.   However,	if  command 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 cre-
		     ation,  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 command
	      Where type is either command, execution or variable.

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

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

	      trace remove variable name opList command
		     If there is a trace set on variable name with  the  operations  and  command
		     given by opList and command, then the trace is removed, so that command 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  com-
		     mand  name.  Each	element  of the list is itself a list containing two ele-
		     ments, which are the opList and command associated with the trace.  If  name
		     doesn't have any traces set, then the result of the command will be an empty
		     string.  If name doesn't exist, the command will throw an error.

	      trace info execution name
		     Returns a list containing one element for each trace currently set  on  com-
		     mand  name.  Each	element  of the list is itself a list containing two ele-
		     ments, which are the opList and command associated with the trace.  If  name
		     doesn't have any traces set, then the result of the command will be an empty
		     string.  If name doesn't exist, the command will throw an error.

	      trace info variable name
		     Returns a list containing one element for each trace currently set on  vari-
		     able  name.   Each  element of the list is itself a list containing two ele-
		     ments, which are the opList and command associated with the trace.  If  name
		     doesn't exist or doesn't 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.

SEE ALSO
       set(n), unset(n)

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

Tcl					       8.4					 trace(n)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 08:03 AM.