Tcl_TraceVar(3) Tcl Library Procedures Tcl_TraceVar(3)

____________________________________________________________________________

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,
const char *name1,
const 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 are
partially formed results stored in the interpreter. If the trace
procedure does anything that could damage this result (such as
calling Tcl_Eval) then it must use the Tcl_SaveInterpState and
related routines to save and restore the original state of the
interpreter 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(n)

KEYWORDS

clientData, trace, variable

Tcl 7.4 Tcl_TraceVar(3)