通讯编程

开发平台：
Visual C++

trace.n：源码内容
							'"
'" Copyright (c) 1993 The Regents of the University of California.
'" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'" Copyright (c) 2000 Ajuba Solutions.
'"
'" See the file "license.terms" for information on usage and redistribution
'" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'" 
'" RCS: @(#) $Id: trace.n,v 1.13.2.2 2004/10/27 14:43:14 dkf Exp $
'" 
.so man.macros
.TH trace n "8.4" Tcl "Tcl Built-In Commands"
.BS
'" Note:  do not modify the .SH NAME line immediately below!
.SH NAME
trace - Monitor variable accesses, command usages and command executions
.SH SYNOPSIS
fBtrace fIoptionfR ?fIarg arg ...fR?
.BE
.SH DESCRIPTION
.PP
This command causes Tcl commands to be executed whenever certain operations are
invoked.  The legal fIoptionfR's (which may be abbreviated) are:
.TP
fBtrace add fItype name ops ?args?fR
Where fItypefR is fBcommandfR, fBexecutionfR, or fBvariablefR.
.RS
.TP
fBtrace add commandfR fIname ops commandfR
Arrange for fIcommandfR to be executed whenever command fInamefR
is modified in one of the ways given by the list fIopsfR.  fINamefR will be
resolved using the usual namespace resolution rules used by
procedures.  If the command does not exist, an error will be thrown.
.RS
.PP
fIOpsfR indicates which operations are of interest, and is a list of
one or more of the following items:
.TP
fBrenamefR
Invoke fIcommandfR whenever the command is renamed.  Note that
renaming to the empty string is considered deletion, and will not
be traced with 'fBrenamefR'.
.TP
fBdeletefR
Invoke fIcommandfR when the command is deleted.  Commands can be
deleted explicitly by using the fBrenamefR 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.
.PP
When the trace triggers, depending on the operations being traced, a 
number of arguments are appended to fIcommandfR so that the actual 
command is as follows:
.CS
fIcommand oldName newName opfR
.CE
fIOldNamefR and fInewNamefR 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).
fIOpfR indicates what operation is being performed on the
command, and is one of fBrenamefR or fBdeletefR 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 fIoldNamefR and fInewNamefR are fully qualified with any namespace(s)
in which they appear.
.RE
.TP
fBtrace add executionfR fIname ops commandfR
Arrange for fIcommandfR to be executed whenever command fInamefR
is executed, with traces occurring at the points indicated by the list
fIopsfR.  fINamefR will be
resolved using the usual namespace resolution rules used by
procedures.  If the command does not exist, an error will be thrown.
.RS
.PP
fIOpsfR indicates which operations are of interest, and is a list of
one or more of the following items:
.TP
fBenterfR
Invoke fIcommandfR whenever the command fInamefR is executed,
just before the actual execution takes place.
.TP
fBleavefR
Invoke fIcommandfR whenever the command fInamefR is executed,
just after the actual execution takes place.
.TP
fBenterstepfR
Invoke fIcommandfR for every Tcl command which is executed 
inside the procedure fInamefR, just before the actual execution
takes place.  For example if we have 'proc foo {} { puts "hello" }',
then an fIenterstepfR trace would be 
invoked just before fIputs "hello"fR is executed.
Setting an fIenterstepfR trace on a fIcommandfR
will not result in an error and is simply ignored.
.TP
fBleavestepfR
Invoke fIcommandfR for every Tcl command which is executed 
inside the procedure fInamefR, just after the actual execution
takes place.
Setting a fIleavestepfR trace on a fIcommandfR
will not result in an error and is simply ignored.
.PP
When the trace triggers, depending on the operations being traced, a 
number of arguments are appended to fIcommandfR so that the actual 
command is as follows:
.PP
For fBenterfR and fBenterstepfR operations:
.CS
fIcommand command-string opfR
.CE
fICommand-stringfR gives the complete current command being 
executed (the traced command for a fBenterfR operation, an 
arbitrary command for a fBenterstepfR operation), including
all arguments in their fully expanded form.
fIOpfR indicates what operation is being performed on the
command execution, and is one of fBenterfR or fBenterstepfR 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.
.PP
For fBleavefR and fBleavestepfR operations:
.CS
fIcommand command-string code result opfR
.CE
fICommand-stringfR gives the complete current command being 
executed (the traced command for a fBenterfR operation, an 
arbitrary command for a fBenterstepfR operation), including
all arguments in their fully expanded form.
fICodefR gives the result code of that execution, and fIresultfR
the result string.
fIOpfR indicates what operation is being performed on the
command execution, and is one of fBleavefR or fBleavestepfR as
defined above.  
Note that the creation of many fBenterstepfR or
fBleavestepfR traces can lead to unintuitive results, since the
invoked commands from one trace can themselves lead to further
command invocations for other traces.
.PP
fICommandfR executes in the same context as the code that invoked
the traced operation: thus the fIcommandfR, 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 fIcommandfR 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.
.PP
While fIcommandfR is executing during an execution trace, traces
on fInamefR are temporarily disabled. This allows the fIcommandfR
to execute fInamefR in its body without invoking any other traces again.
If an error occurs while executing the fIcommandfR body, then the
command fInamefR as a whole will return that same error.
.PP
When multiple traces are set on fInamefR, then for fIenterfR
and fIenterstepfR operations, the traced commands are invoked
in the reverse order of how the traces were originally created;
and for fIleavefR and fIleavestepfR operations, the traced
commands are invoked in the original order of creation.
.PP
The behavior of execution traces is currently undefined for a command 
fInamefR imported into another namespace.
.RE
.TP
fBtrace add variablefI name ops commandfR
Arrange for fIcommandfR to be executed whenever variable fInamefR
is accessed in one of the ways given by the list fIopsfR.  fINamefR may
refer to a normal variable, an element of an array, or to an array
as a whole (i.e. fInamefR may be just the name of an array, with no
parenthesized index).  If fInamefR refers to a whole array, then
fIcommandfR 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 fBnamespace whichfR
queries, but not to fBinfo existsfR queries.
.RS
.PP
fIOpsfR indicates which operations are of interest, and is a list of
one or more of the following items:
.TP
fBarrayfR
Invoke fIcommandfR whenever the variable is accessed or modified via
the fBarrayfR command, provided that fInamefR is not a scalar
variable at the time that the fBarrayfR command is invoked.  If
fInamefR is a scalar variable, the access via the fBarrayfR
command will not trigger the trace.
.TP
fBreadfR
Invoke fIcommandfR whenever the variable is read.
.TP
fBwritefR
Invoke fIcommandfR whenever the variable is written.
.TP
fBunsetfR
Invoke fIcommandfR whenever the variable is unset.  Variables
can be unset explicitly with the fBunsetfR 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.
.PP
When the trace triggers, three arguments are appended to
fIcommandfR so that the actual command is as follows:
.CS
fIcommand name1 name2 opfR
.CE
fIName1fR and fIname2fR give the name(s) for the variable
being accessed:  if the variable is a scalar then fIname1fR
gives the variable's name and fIname2fR is an empty string;
if the variable is an array element then fIname1fR 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 fIname1fR
gives the array name and fIname2fR is an empty string.
fIName1fR and fIname2fR are not necessarily the same as the
name used in the fBtrace variablefR command:  the fBupvarfR
command allows a procedure to reference a variable under a
different name.
fIOpfR indicates what operation is being performed on the
variable, and is one of fBreadfR, fBwritefR, or fBunsetfR as
defined above.
.PP
fICommandfR 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 fIcommandfR 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 fIcommandfR
invokes a procedure (which it normally does) then the procedure will
have to use fBupvarfR or fBuplevelfR if it wishes to access the
traced variable.  Note also that fIname1fR 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 fBupvarfR command.
.PP
For read and write traces, fIcommandfR can modify the variable to
affect the result of the traced operation.  If fIcommandfR 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  fIcommandfR 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, fIcommandfR 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, fIcommandfR will have to restore the
old value of the variable.
.PP
While fIcommandfR is executing during a read or write trace, traces
on the variable are temporarily disabled.  This means that reads and
writes invoked by fIcommandfR will occur directly, without invoking
fIcommandfR (or any other traces) again.  However, if fIcommandfR
unsets the variable then unset traces will be invoked.
.PP
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.
.PP
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.
.PP
Once created, the trace remains in effect either until the trace is
removed with the fBtrace remove variablefR 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.
.PP
This command returns an empty string.
.RE
.RE
.TP
fBtrace remove fItype name opList commandfR
Where fItypefR is either fBcommandfR, fBexecutionfR or fBvariablefR.
.RS
.TP
fBtrace remove commandfI name opList commandfR
If there is a trace set on command fInamefR with the operations and
command given by fIopListfR and fIcommandfR, then the trace is
removed, so that fIcommandfR will never again be invoked.  Returns
an empty string.   If fInamefR doesn't exist, the command will throw
an error.
.TP
fBtrace remove executionfI name opList commandfR
If there is a trace set on command fInamefR with the operations and
command given by fIopListfR and fIcommandfR, then the trace is
removed, so that fIcommandfR will never again be invoked.  Returns
an empty string.   If fInamefR doesn't exist, the command will throw
an error.
.TP
fBtrace remove variablefI name opList commandfR
If there is a trace set on variable fInamefR with the operations and
command given by fIopListfR and fIcommandfR, then the trace is
removed, so that fIcommandfR will never again be invoked.  Returns
an empty string.
.RE
.TP
fBtrace info fItype namefR
Where fItypefR is either fBcommandfR, fBexecutionfR or fBvariablefR.
.RS
.TP
fBtrace info commandfI namefR
Returns a list containing one element for each trace currently set on
command fInamefR. Each element of the list is itself a list
containing two elements, which are the fIopListfR and fIcommandfR
associated with the trace.  If fInamefR doesn't have any traces set,
then the result of the command will be an empty string.  If fInamefR
doesn't exist, the command will throw an error.
.TP
fBtrace info executionfI namefR
Returns a list containing one element for each trace currently set on
command fInamefR. Each element of the list is itself a list
containing two elements, which are the fIopListfR and fIcommandfR
associated with the trace.  If fInamefR doesn't have any traces set,
then the result of the command will be an empty string.  If fInamefR
doesn't exist, the command will throw an error.
.TP
fBtrace info variablefI namefR
Returns a list containing one element for each trace currently set on
variable fInamefR.  Each element of the list is itself a list
containing two elements, which are the fIopListfR and fIcommandfR
associated with the trace.  If fInamefR doesn't exist or doesn't
have any traces set, then the result of the command will be an empty
string.
.RE
.PP
For backwards compatibility, three other subcommands are available:
.RS
.TP
fBtrace variable fIname ops commandfR
This is equivalent to fBtrace add variable fIname ops commandfR.
.TP
fBtrace vdelete fIname ops commandfR
This is equivalent to fBtrace remove variable fIname ops commandfR
.TP 
fBtrace vinfo fInamefR 
This is equivalent to fBtrace info variable fInamefR
.RE
.PP
These subcommands are deprecated and will likely be removed in a
future version of Tcl.  They use an older syntax in which fBarrayfR,
fBreadfR, fBwritefR, fBunsetfR are replaced by fBafR, fBrfR,
fBwfR and fBufR respectively, and the fIopsfR argument is not a
list, but simply a string concatenation of the operations, such as
fBrwuafR.
.SH EXAMPLES
Print a message whenever either of the global variables fBfoofR and
fBbarfR are updated, even if they have a different local name at the
time (which can be done with the fBupvarfR command):
.CS
proc tracer {varname args} {
    upvar #0 $varname var
    puts "$varname was updated to be e"$vare""
}
fBtrace addfR variable foo write "tracer foo"
fBtrace addfR variable bar write "tracer bar"
.CE
.PP
Ensure that the global variable fBfoobarfR always contains the
product of the global variables fBfoofR and fBbarfR:
.CS
proc doMult args {
    global foo bar foobar
    set foobar [expr {$foo * $bar}]
}
fBtrace addfR variable foo write doMult
fBtrace addfR variable bar write doMult
.CE
.SH "SEE ALSO"
set(n), unset(n)
.SH KEYWORDS
read, command, rename, variable, write, trace, unset

						