NAME¶
Tcl_TraceVar, Tcl_TraceVar2, Tcl_UntraceVar, Tcl_UntraceVar2, Tcl_VarTraceInfo,
Tcl_VarTraceInfo2 - monitor accesses to a variable
SYNOPSIS¶
#include <tcl.h>
int
Tcl_TraceVar(interp, varName, flags, proc, clientData)
int
Tcl_TraceVar2(interp, name1, name2, flags, proc, clientData)
Tcl_UntraceVar(interp, varName, flags, proc, clientData)
Tcl_UntraceVar2(interp, name1, name2, flags, proc, clientData)
ClientData
Tcl_VarTraceInfo(interp, varName, flags, proc, prevClientData)
ClientData
Tcl_VarTraceInfo2(interp, name1, name2, flags, proc, prevClientData)
ARGUMENTS¶
- Tcl_Interp *interp (in)
- Interpreter containing variable.
- const char *varName (in)
- Name of variable. May refer to a scalar variable, to an array variable
with no index, or to an array variable with a parenthesized index.
- int flags (in)
- OR-ed combination of the values TCL_TRACE_READS,
TCL_TRACE_WRITES, TCL_TRACE_UNSETS, TCL_TRACE_ARRAY,
TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
TCL_TRACE_RESULT_DYNAMIC and TCL_TRACE_RESULT_OBJECT. Not
all flags are used by all procedures. See below for more information.
- Tcl_VarTraceProc *proc (in)
- Procedure to invoke whenever one of the traced operations occurs.
- ClientData clientData (in)
- Arbitrary one-word value to pass to proc.
- const char *name1 (in)
- Name of scalar or array variable (without array index).
- const char *name2 (in)
- For a trace on an element of an array, gives the index of the element. For
traces on scalar variables or on whole arrays, is NULL.
- ClientData prevClientData (in)
- If non-NULL, gives last value returned by Tcl_VarTraceInfo or
Tcl_VarTraceInfo2, so this call will return information about next
trace. If NULL, this call will return information about first trace.
DESCRIPTION¶
Tcl_TraceVar allows a C procedure to monitor and control access to a Tcl
variable, so that the C procedure is invoked whenever the variable is read or
written or unset. If the trace is created successfully then
Tcl_TraceVar returns
TCL_OK. If an error occurred (e.g.
varName specifies an element of an array, but the actual variable is
not an array) then
TCL_ERROR is returned and an error message is left
in the interpreter's result.
The
flags argument to
Tcl_TraceVar indicates when the trace
procedure is to be invoked and provides information for setting up the trace.
It consists of an OR-ed combination of any of the following values:
- TCL_GLOBAL_ONLY
- Normally, the variable will be looked up at the current level of procedure
call; if this bit is set then the variable will be looked up at global
level, ignoring any active procedures.
- TCL_NAMESPACE_ONLY
- Normally, the variable will be looked up at the current level of procedure
call; if this bit is set then the variable will be looked up in the
current namespace, ignoring any active procedures.
- TCL_TRACE_READS
- Invoke proc whenever an attempt is made to read the variable.
- TCL_TRACE_WRITES
- Invoke proc whenever an attempt is made to modify the
variable.
- TCL_TRACE_UNSETS
- Invoke proc whenever the variable is unset. A variable may be unset
either explicitly by an unset command, or implicitly when a
procedure returns (its local variables are automatically unset) or when
the interpreter is deleted (all variables are automatically unset).
- TCL_TRACE_ARRAY
- Invoke proc whenever the array command is invoked. This gives the
trace procedure a chance to update the array before array names or array
get is called. Note that this is called before an array set, but that will
trigger write traces.
- TCL_TRACE_RESULT_DYNAMIC
- The result of invoking the proc is a dynamically allocated string
that will be released by the Tcl library via a call to ckfree. Must
not be specified at the same time as TCL_TRACE_RESULT_OBJECT.
- TCL_TRACE_RESULT_OBJECT
- The result of invoking the proc is a Tcl_Obj* (cast to a char*)
with a reference count of at least one. The ownership of that reference
will be transferred to the Tcl core for release (when the core has
finished with it) via a call to Tcl_DecrRefCount. Must not be
specified at the same time as TCL_TRACE_RESULT_DYNAMIC.
Whenever one of the specified operations occurs on the variable,
proc
will be invoked. It should have arguments and result that match the type
Tcl_VarTraceProc:
typedef char * Tcl_VarTraceProc(
ClientData clientData,
Tcl_Interp * interp,
char * name1,
char * name2,
int flags);
The
clientData and
interp parameters will have the same values as
those passed to
Tcl_TraceVar when the trace was created.
ClientData typically points to an application-specific data structure
that describes what to do when
proc is invoked.
Name1 and
name2 give the name of the traced variable in the normal two-part form
(see the description of
Tcl_TraceVar2 below for details).
Flags
is an OR-ed combination of bits providing several pieces of information. One
of the bits
TCL_TRACE_READS,
TCL_TRACE_WRITES,
TCL_TRACE_ARRAY, or
TCL_TRACE_UNSETS will be set in
flags
to indicate which operation is being performed on the variable. The bit
TCL_GLOBAL_ONLY will be set whenever the variable being accessed is a
global one not accessible from the current level of procedure call: the trace
procedure will need to pass this flag back to variable-related procedures like
Tcl_GetVar if it attempts to access the variable. The bit
TCL_NAMESPACE_ONLY will be set whenever the variable being accessed is
a namespace one not accessible from the current level of procedure call: the
trace procedure will need to pass this flag back to variable-related
procedures like
Tcl_GetVar if it attempts to access the variable. The
bit
TCL_TRACE_DESTROYED will be set in
flags if the trace is
about to be destroyed; this information may be useful to
proc so that
it can clean up its own internal data structures (see the section
TCL_TRACE_DESTROYED below for more details). Lastly, the bit
TCL_INTERP_DESTROYED will be set if the entire interpreter is being
destroyed. When this bit is set,
proc must be especially careful in the
things it does (see the section
TCL_INTERP_DESTROYED below). The trace
procedure's return value should normally be NULL; see
ERROR RETURNS
below for information on other possibilities.
Tcl_UntraceVar may be used to remove a trace. If the variable specified
by
interp,
varName, and
flags has a trace set with
flags,
proc, and
clientData, then the corresponding trace
is removed. If no such trace exists, then the call to
Tcl_UntraceVar
has no effect. The same bits are valid for
flags as for calls to
Tcl_TraceVar.
Tcl_VarTraceInfo may be used to retrieve information about traces set on
a given variable. The return value from
Tcl_VarTraceInfo is the
clientData associated with a particular trace. The trace must be on the
variable specified by the
interp,
varName, and
flags
arguments (only the
TCL_GLOBAL_ONLY and
TCL_NAMESPACE_ONLY bits
from
flags is used; other bits are ignored) and its trace procedure
must the same as the
proc argument. If the
prevClientData
argument is NULL then the return value corresponds to the first (most recently
created) matching trace, or NULL if there are no matching traces. If the
prevClientData argument is not NULL, then it should be the return value
from a previous call to
Tcl_VarTraceInfo. In this case, the new return
value will correspond to the next matching trace after the one whose
clientData matches
prevClientData, or NULL if no trace matches
prevClientData or if there are no more matching traces after it. This
mechanism makes it possible to step through all of the traces for a given
variable that have the same
proc.
TWO-PART NAMES¶
The procedures
Tcl_TraceVar2,
Tcl_UntraceVar2, and
Tcl_VarTraceInfo2 are identical to
Tcl_TraceVar,
Tcl_UntraceVar, and
Tcl_VarTraceInfo, respectively, except that
the name of the variable consists of two parts.
Name1 gives the name of
a scalar variable or array, and
name2 gives the name of an element
within an array. When
name2 is NULL,
name1 may contain both an
array and an element name: if the name contains an open parenthesis and ends
with a close parenthesis, then the value between the parentheses is treated as
an element name (which can have any string value) and the characters before
the first open parenthesis are treated as the name of an array variable. If
name2 is NULL and
name1 does not refer to an array element it
means that either the variable is a scalar or the trace is to be set on the
entire array rather than an individual element (see WHOLE-ARRAY TRACES below
for more information).
ACCESSING VARIABLES DURING TRACES¶
During read, write, and array traces, the trace procedure can read, write, or
unset the traced variable using
Tcl_GetVar2,
Tcl_SetVar2, and
other procedures. While
proc is executing, traces are temporarily
disabled for the variable, so that calls to
Tcl_GetVar2 and
Tcl_SetVar2 will not cause
proc or other trace procedures to be
invoked again. Disabling only occurs for the variable whose trace procedure is
active; accesses to other variables will still be traced. However, if a
variable is unset during a read or write trace then unset traces will be
invoked.
During unset traces the variable has already been completely expunged. It is
possible for the trace procedure to read or write the variable, but this will
be a new version of the variable. Traces are not disabled during unset traces
as they are for read and write traces, but existing traces have been removed
from the variable before any trace procedures are invoked. If new traces are
set by unset trace procedures, these traces will be invoked on accesses to the
variable by the trace procedures.
CALLBACK TIMING¶
When read tracing has been specified for a variable, the trace procedure will be
invoked whenever the variable's value is read. This includes
set Tcl
commands,
$-notation in Tcl commands, and invocations of the
Tcl_GetVar and
Tcl_GetVar2 procedures.
Proc is invoked
just before the variable's value is returned. It may modify the value of the
variable to affect what is returned by the traced access. If it unsets the
variable then the access will return an error just as if the variable never
existed.
When write tracing has been specified for a variable, the trace procedure will
be invoked whenever the variable's value is modified. This includes
set
commands, commands that modify variables as side effects (such as
catch
and
scan), and calls to the
Tcl_SetVar and
Tcl_SetVar2
procedures).
Proc will be invoked after the variable's value has been
modified, but before the new value of the variable has been returned. It may
modify the value of the variable to override the change and to determine the
value actually returned by the traced access. If it deletes the variable then
the traced access will return an empty string.
When array tracing has been specified, the trace procedure will be invoked at
the beginning of the array command implementation, before any of the
operations like get, set, or names have been invoked. The trace procedure can
modify the array elements with
Tcl_SetVar and
Tcl_SetVar2.
When unset tracing has been specified, the trace procedure will be invoked
whenever the variable is destroyed. The traces will be called after the
variable has been completely unset.
WHOLE-ARRAY TRACES¶
If a call to
Tcl_TraceVar or
Tcl_TraceVar2 specifies the name of
an array variable without an index into the array, then the trace will be set
on the array as a whole. This means that
proc will be invoked whenever
any element of the array is accessed in the ways specified by
flags.
When an array is unset, a whole-array trace will be invoked just once, with
name1 equal to the name of the array and
name2 NULL; it will not
be invoked once for each element.
MULTIPLE TRACES¶
It is possible for multiple traces to exist on the same variable. When this
happens, all of the trace procedures will be invoked on each access, in order
from most-recently-created to least-recently-created. When there exist
whole-array traces for an array as well as traces on individual elements, the
whole-array traces are invoked before the individual-element traces. If a read
or write trace unsets the variable then all of the unset traces will be
invoked but the remainder of the read and write traces will be skipped.
ERROR RETURNS¶
Under normal conditions trace procedures should return NULL, indicating
successful completion. If
proc returns a non-NULL value it signifies
that an error occurred. The return value must be a pointer to a static
character string containing an error message, unless (
exactly one of)
the
TCL_TRACE_RESULT_DYNAMIC and
TCL_TRACE_RESULT_OBJECT flags
is set, which specify that the result is either a dynamic string (to be
released with
ckfree) or a Tcl_Obj* (cast to char* and to be released
with
Tcl_DecrRefCount) containing the error message. If a trace
procedure returns an error, no further traces are invoked for the access and
the traced access aborts with the given message. Trace procedures can use this
facility to make variables read-only, for example (but note that the value of
the variable will already have been modified before the trace procedure is
called, so the trace procedure will have to restore the correct value).
The return value from
proc is only used during read and write tracing.
During unset traces, the return value is ignored and all relevant trace
procedures will always be invoked.
RESTRICTIONS¶
A trace procedure can be called at any time, even when there is a partially
formed result in the interpreter's result area. If the trace procedure does
anything that could damage this result (such as calling
Tcl_Eval) then
it must save the original values of the interpreter's
result and
freeProc fields and restore them before it returns.
UNDEFINED VARIABLES¶
It is legal to set a trace on an undefined variable. The variable will still
appear to be undefined until the first time its value is set. If an undefined
variable is traced and then unset, the unset will fail with an error
(“no such variable”), but the trace procedure will still be
invoked.
TCL_TRACE_DESTROYED FLAG¶
In an unset callback to
proc, the
TCL_TRACE_DESTROYED bit is set
in
flags if the trace is being removed as part of the deletion. Traces
on a variable are always removed whenever the variable is deleted; the only
time
TCL_TRACE_DESTROYED is not set is for a whole-array trace invoked
when only a single element of an array is unset.
TCL_INTERP_DESTROYED¶
When an interpreter is destroyed, unset traces are called for all of its
variables. The
TCL_INTERP_DESTROYED bit will be set in the
flags
argument passed to the trace procedures. Trace procedures must be extremely
careful in what they do if the
TCL_INTERP_DESTROYED bit is set. It is
not safe for the procedures to invoke any Tcl procedures on the interpreter,
since its state is partially deleted. All that trace procedures should do
under these circumstances is to clean up and free their own internal data
structures.
BUGS¶
Tcl does not do any error checking to prevent trace procedures from misusing the
interpreter during traces with
TCL_INTERP_DESTROYED set.
Array traces are not yet integrated with the Tcl
info exists command, nor
is there Tcl-level access to array traces.
SEE ALSO¶
trace(3tcl)
KEYWORDS¶
clientData, trace, variable