Man Pages

Tcl_TraceVar(3) - phpMan Tcl_TraceVar(3) - phpMan

Command: man perldoc info search(apropos)  


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 parenthe-
                                                     sized 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 proce-
                                                     dures.  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 com-
              mand, 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 fin-
              ished 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 argu-
       ments 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  pro-
       cedure call:  the trace procedure will need to pass this flag back to variable-related procedures like Tcl_Get-
       Var 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  vari-
       able.   The  bit TCL_TRACE_DESTROYED will be set in flags if the trace is about to be destroyed;  this informa-
       tion 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 possi-
       ble 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 parenthe-
       sis 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 vari-
       able'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 vari-
       able'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 vari-
       able'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  com-
       mand  implementation, before any of the operations like get, set, or names have been invoked.  The trace proce-
       dure 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 proce-
       dures 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 mes-
       sage.  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 care-
       ful 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.

KEYWORDS
       clientData, trace, variable



Tcl                                   7.4                      Tcl_TraceVar(3)