trace - Monitor variable accesses, command usages and command executions
Examples of what to do with [trace]:
JCW:
proc tellme {id a e op} {
puts " $id a=$a e=$e op=$op\
ax=[info exists ::$a] ex=[info exists ::${a}($e)]"
}
proc do {args} {
puts "<$args>"
uplevel $args
}
trace var a wu {tellme array}
trace var a(1) wu {tellme element}
puts [trace vinfo a]
puts [trace vinfo a(1)]
do set a(0) zero
do set a(1) one
do set a(2) two
do unset a(0)
do unset a(2)
do unset a
# output is:
#
# {wu {tellme array}}
# {wu {tellme element}}
# <set a(0) zero>
# array a=a e=0 op=w ax=1 ex=1
# <set a(1) one>
# array a=a e=1 op=w ax=1 ex=1
# element a=a e=1 op=w ax=1 ex=1
# <set a(2) two>
# array a=a e=2 op=w ax=1 ex=1
# <unset a(0)>
# array a=a e=0 op=u ax=1 ex=0
# <unset a(2)>
# array a=a e=2 op=u ax=1 ex=0
# <unset a>
# array a=a e= op=u ax=0 ex=0
# element a=a e=1 op=u ax=0 ex=0On comp.lang.tcl, 2004-05, CLN answers Erik Leunissen's question: Erik Leunissen wrote:
> The following passage from the man page to the trace command is
> mystifying to me:
>
> "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."
>
> I've read it again and again; I can't imagine how a procedure return
> affects/causes an unset.
> ...
proc foo { } {
set x 1
trace variable x u {some code here}
}
When foo is invoked, x is created (locally), has a trace associated with
it, then becomes unset as foo exits.Non-array variables give a null string for the name2 argument in the trace invocation, but the null string is a perfectly valid array index (it is also a valid array variable name), so a null value for name2 doesn't necessarily indicate that the traced variable is scalar. To determine whether a variable is an array, use:
if { [array exists $varname] } {...All of the following operations result in the argument values a {} u:
unset a ;# regular var a array unset a unset a()
including a null index string. [array exists] always returns false for the first two cases, and true for the third (even if the null index was the only array element). There is no way for the trace to be sure which operation was performed.
Lars H: Hmm... might this be a sign that the format of these parameter lists is not well designed? An alternative would have been to put the operation first and the variable name second, so that there needn't be an index for non-array accesses. Probably too late to change now, though. (Adding a second interface which is just like the current except that it produces parameter lists in a new format is possible, but probably seen as superfluous.)
male 2006-01-24: I had the problem, that I wanted to trace the creation of an array element and used the write event. But ... the write event is fired, after the new array element was already created! What's about a new event like "create"? Since a trace may be created on non-existent variables, this could be useful not only for arrays.
Donald Arseneau Yes, write traces fire after the variable has already been set, so if you want validation of variables' values, in analogy with Tk's entry validation, then you must maintain shadow copies of the previous values, in order to undo improper settings.
On comp.lang.tcl, Kevin Kenny answers someone wanting to link a C variable and a Tcl variable, and have a Tcl proc invoked when the C code modified the variable:
trace var stdout w {puts stdout $stdout ;#}
trace var stdin r {gets stdin stdin ;#}The variables are named like the file handles. Little demo, that waits for input and prints it capitalized:
set stdout [string toupper $stdin]
Traces are like widgets and images in that they are resources that can be leaked and/or need clean-up. Counter-intuitive results sometimes arise because traces are additive rather than substitutive; a particular trace can fire a whole chain of commands. To wipe the global space clean of traces,
foreach variable [info glob] {
foreach pair [trace info variable ::$variable] {
foreach {op traced_command} $pair {}
set op [string range $op 0 0]
trace vdelete ::$variable $op $traced_command
}
}enterstep and leavestep traces fire for all steps, recursively. When this is undesired, the depth of the recursion can be constrained by having the trace procedure look at [info level].
Donald Arseneau Another tricky trap is that errors in traces may give error messages, but no context; the only context is for whatever triggered the trace. Thus, if you ever see Tk error messages like
can't set "xv": invalid command name "oops"
while executing
"incr xv"then you should look for a variable trace on the xv variable.
Schnexel Oh the tricky trace traps! I tried to automaticly update a derivedData array by setting a trace on the parentData array (scenario simplified)... Now I get a surreal result:
set bla "What happened:\n"
namespace eval bbb {
array set lala [list 1 v1 2 v2 3 v3]
trace add variable ::bbb::lala {read array} ::bbb::tra
proc tra { args } {
append ::bla "\n (TRACE $args)"
array unset ::bbb::lala ;# also deletes trace (yet the "array" op still fires)
foreach {n v} [list 1 trv1 2 trv2 3 trv3] { set ::bbb::lala($n) $v }
}
}
namespace eval aaa {
append ::bla "\n\[info exists ::bbb::lala(1)\]==..."; append ::bla ... [info exists ::bbb::lala(1)]
append ::bla "\n\[info exists ::bbb::lala(1)\]==..."; append ::bla ... [info exists ::bbb::lala(1)]
append ::bla "\n\$::bbb::lala(1)==..."; append ::bla ... $::bbb::lala(1)
}
puts $blawhich gives the output
What happened:
[info exists ::bbb::lala(1)]==...
(TRACE ::bbb::lala 1 read)
(TRACE ::bbb::lala {} array)...0
[info exists ::bbb::lala(1)]==......1
$::bbb::lala(1)==......trv1So, upon first read access of lala, it does not exist anymore, whilst upon second read it is there. Can anybody make sense of this?
Lars H: Regarding why the "array" op fires: It it fires at the very [array unset ::bbb::lala] where you comment upon this, i.e., before the foreach, which is consistent with the trace manpage (only read and write traces are disabled inside a read or write trace). But why info exists reports 0 I don't know... Perhaps some caching issue (the variable that was looked up is not the one that is there when the result is returned)? You'll probably need to read the source to find out.
Schnexel: Wrrr... Here´s a simpler example. Array trace is bugged!
array set ::lala [list 1 v1 2 v2]
array set ::lala [list 3 v3 4 v4]
puts "\$::lala==[array get ::lala]" ;# O.K.
trace add variable ::lala read ::tra
proc tra { args } {
puts " (TRACE $args)"
trace remove variable ::lala read ::tra
array set ::lala [list A trvA B trvB]
puts " within trace: \$::lala==[array get ::lala]" ;# O.K.
}
puts "1st read outside: \$::lala==[array get ::lala]" ;# not O.K. !
puts "2nd read outside: \$::lala==[array get ::lala]" ;# O.K.Output:
$::lala==4 v4 1 v1 2 v2 3 v3
reading ::lala
(TRACE ::lala 4 read)
within trace: $::lala==4 v4 A trvA 1 v1 B trvB 2 v2 3 v3
1st read outside: $::lala==4 v4 1 v1 2 v2 3 v3
2nd read outside: $::lala==4 v4 A trvA 1 v1 B trvB 2 v2 3 v3PYK 2013-12-22: The result of a command run as a trace are currently discarded. It could instead be used as the command to actually call. For exampe, the result of the following script would be 12, not 21
proc add {args} {
::tcl::mathop::+ {*}$args
}
trace add execution add enter {apply {{cmd op} {
set args [lassign $cmd name]
foreach arg $args[set args {}] {
if {$arg % 2 == 0} {
lappend args $arg
}
}
return [linsert $args 0 $name]
}}}
add 1 2 3 4 5 6