geos_one/archie
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d896ff745c
archie/tcl7.6/generic/tclVar.c
Mario Fetka b2af3b41bd Update tcl/tk for tcl-dp
2024-05-27 16:40:40 +02:00

2585 lines
73 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* tclVar.c --
*
* This file contains routines that implement Tcl variables
* (both scalars and arrays).
*
* The implementation of arrays is modelled after an initial
* implementation by Mark Diekhans and Karl Lehenbauer.
*
* Copyright (c) 1987-1994 The Regents of the University of California.
* Copyright (c) 1994-1995 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* SCCS: @(#) tclVar.c 1.74 96/10/08 08:26:09
*/
#include "tclInt.h"
#include "tclPort.h"
/*
* The strings below are used to indicate what went wrong when a
* variable access is denied.
*/
static char *noSuchVar = "no such variable";
static char *isArray = "variable is array";
static char *needArray = "variable isn't array";
static char *noSuchElement = "no such element in array";
static char *danglingUpvar = "upvar refers to element in deleted array";
/*
* Creation flag values passed in to LookupVar:
*
* CRT_PART1 - 1 means create hash table entry for part 1 of
* name, if it doesn't already exist. 0 means
* return an error if it doesn't exist.
* CRT_PART2 - 1 means create hash table entry for part 2 of
* name, if it doesn't already exist. 0 means
* return an error if it doesn't exist.
*/
#define CRT_PART1 1
#define CRT_PART2 2
/*
* The following additional flag is used internally and passed through
* to LookupVar to indicate that a procedure like Tcl_GetVar was called
* instead of Tcl_GetVar2 and the single name value hasn't yet been
* parsed into an array name and index (if any).
*/
#define PART1_NOT_PARSED 0x10000
/*
* Forward references to procedures defined later in this file:
*/
static char * CallTraces _ANSI_ARGS_((Interp *iPtr, Var *arrayPtr,
Var *varPtr, char *part1, char *part2,
int flags));
static void CleanupVar _ANSI_ARGS_((Var *varPtr, Var *arrayPtr));
static void DeleteSearches _ANSI_ARGS_((Var *arrayVarPtr));
static void DeleteArray _ANSI_ARGS_((Interp *iPtr, char *arrayName,
Var *varPtr, int flags));
static Var * LookupVar _ANSI_ARGS_((Tcl_Interp *interp, char *part1,
char *part2, int flags, char *msg, int create,
Var **arrayPtrPtr));
static int MakeUpvar _ANSI_ARGS_((Interp *iPtr,
CallFrame *framePtr, char *otherP1,
char *otherP2, char *myName, int flags));
static Var * NewVar _ANSI_ARGS_((void));
static ArraySearch * ParseSearchId _ANSI_ARGS_((Tcl_Interp *interp,
Var *varPtr, char *varName, char *string));
static void VarErrMsg _ANSI_ARGS_((Tcl_Interp *interp,
char *part1, char *part2, char *operation,
char *reason));
/*
*----------------------------------------------------------------------
*
* LookupVar --
*
* This procedure is used by virtually all of the variable
* code to locate a variable given its name(s).
*
* Results:
* The return value is a pointer to the variable indicated by
* part1 and part2, or NULL if the variable couldn't be found.
* If the variable is found, *arrayPtrPtr is filled in with
* the address of the array that contains the variable (or NULL
* if the variable is a scalar). Note: it's possible that the
* variable returned may be VAR_UNDEFINED, even if CRT_PART1 and
* CRT_PART2 are specified (these only cause the hash table entry
* and/or array to be created).
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static Var *
LookupVar(interp, part1, part2, flags, msg, create, arrayPtrPtr)
Tcl_Interp *interp; /* Interpreter to use for lookup. */
char *part1; /* If part2 isn't NULL, this is the name
* of an array. Otherwise, if the
* PART1_NOT_PARSED flag bit is set this
* is a full variable name that could
* include a parenthesized array elemnt.
* If PART1_NOT_PARSED isn't present, then
* this is the name of a scalar variable. */
char *part2; /* Name of an element within array, or NULL. */
int flags; /* Only the TCL_GLOBAL_ONLY, TCL_LEAVE_ERR_MSG,
* and PART1_NOT_PARSED bits matter. */
char *msg; /* Verb to use in error messages, e.g.
* "read" or "set". Only needed if
* TCL_LEAVE_ERR_MSG is set in flags. */
int create; /* OR'ed combination of CRT_PART1 and
* CRT_PART2. Tells which entries to create
* if they don't already exist. */
Var **arrayPtrPtr; /* If the name refers to an element of an
* array, *arrayPtrPtr gets filled in with
* address of array variable. Otherwise
* this is set to NULL. */
{
Interp *iPtr = (Interp *) interp;
Tcl_HashTable *tablePtr;
Tcl_HashEntry *hPtr;
Var *varPtr;
int new;
char *openParen, *closeParen; /* If this procedure parses a name
* into array and index, these point
* to the parens around the index.
* Otherwise they are NULL. These
* are needed to restore the parens
* after parsing the name. */
char *elName; /* Name of array element or NULL;
* may be same as part2, or may be
* openParen+1. */
char *p;
/*
* If the name hasn't been parsed into array name and index yet,
* do it now.
*/
openParen = closeParen = NULL;
elName = part2;
if (flags & PART1_NOT_PARSED) {
for (p = part1; ; p++) {
if (*p == 0) {
elName = NULL;
break;
}
if (*p == '(') {
openParen = p;
do {
p++;
} while (*p != '\0');
p--;
if (*p == ')') {
closeParen = p;
*openParen = 0;
elName = openParen+1;
} else {
openParen = NULL;
elName = NULL;
}
break;
}
}
}
/*
* Lookup part1.
*/
*arrayPtrPtr = NULL;
if ((flags & TCL_GLOBAL_ONLY) || (iPtr->varFramePtr == NULL)) {
tablePtr = &iPtr->globalTable;
} else {
tablePtr = &iPtr->varFramePtr->varTable;
}
if (create & CRT_PART1) {
hPtr = Tcl_CreateHashEntry(tablePtr, part1, &new);
if (openParen != NULL) {
*openParen = '(';
}
if (new) {
varPtr = NewVar();
Tcl_SetHashValue(hPtr, varPtr);
varPtr->hPtr = hPtr;
}
} else {
hPtr = Tcl_FindHashEntry(tablePtr, part1);
if (openParen != NULL) {
*openParen = '(';
}
if (hPtr == NULL) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, msg, noSuchVar);
}
return NULL;
}
}
varPtr = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr->flags & VAR_UPVAR) {
varPtr = varPtr->value.upvarPtr;
}
if (elName == NULL) {
return varPtr;
}
/*
* We're dealing with an array element, so make sure the variable
* is an array and lookup the element (create it if desired).
*/
if (varPtr->flags & VAR_UNDEFINED) {
if (!(create & CRT_PART1)) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, msg, noSuchVar);
}
return NULL;
}
varPtr->flags = VAR_ARRAY;
varPtr->value.tablePtr = (Tcl_HashTable *)
ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(varPtr->value.tablePtr, TCL_STRING_KEYS);
} else if (!(varPtr->flags & VAR_ARRAY)) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, msg, needArray);
}
return NULL;
}
*arrayPtrPtr = varPtr;
if (closeParen != NULL) {
*closeParen = 0;
}
if (create & CRT_PART2) {
hPtr = Tcl_CreateHashEntry(varPtr->value.tablePtr, elName, &new);
if (closeParen != NULL) {
*closeParen = ')';
}
if (new) {
if (varPtr->searchPtr != NULL) {
DeleteSearches(varPtr);
}
varPtr = NewVar();
Tcl_SetHashValue(hPtr, varPtr);
varPtr->hPtr = hPtr;
}
} else {
hPtr = Tcl_FindHashEntry(varPtr->value.tablePtr, elName);
if (closeParen != NULL) {
*closeParen = ')';
}
if (hPtr == NULL) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, msg, noSuchElement);
}
return NULL;
}
}
return (Var *) Tcl_GetHashValue(hPtr);
}
/*
*----------------------------------------------------------------------
*
* Tcl_GetVar --
*
* Return the value of a Tcl variable.
*
* Results:
* The return value points to the current value of varName. If
* the variable is not defined or can't be read because of a clash
* in array usage then a NULL pointer is returned and an error
* message is left in interp->result if the TCL_LEAVE_ERR_MSG
* flag is set. Note: the return value is only valid up until
* the next call to Tcl_SetVar or Tcl_SetVar2; if you depend on
* the value lasting longer than that, then make yourself a private
* copy.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
char *
Tcl_GetVar(interp, varName, flags)
Tcl_Interp *interp; /* Command interpreter in which varName is
* to be looked up. */
char *varName; /* Name of a variable in interp. */
int flags; /* OR-ed combination of TCL_GLOBAL_ONLY
* or TCL_LEAVE_ERR_MSG bits. */
{
return Tcl_GetVar2(interp, varName, (char *) NULL,
flags | PART1_NOT_PARSED);
}
/*
*----------------------------------------------------------------------
*
* Tcl_GetVar2 --
*
* Return the value of a Tcl variable, given a two-part name
* consisting of array name and element within array.
*
* Results:
* The return value points to the current value of the variable
* given by part1 and part2. If the specified variable doesn't
* exist, or if there is a clash in array usage, then NULL is
* returned and a message will be left in interp->result if the
* TCL_LEAVE_ERR_MSG flag is set. Note: the return value is
* only valid up until the next call to Tcl_SetVar or Tcl_SetVar2;
* if you depend on the value lasting longer than that, then make
* yourself a private copy.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
char *
Tcl_GetVar2(interp, part1, part2, flags)
Tcl_Interp *interp; /* Command interpreter in which variable is
* to be looked up. */
char *part1; /* Name of array (if part2 is NULL) or
* name of variable. */
char *part2; /* If non-null, gives name of element in
* array. */
int flags; /* OR-ed combination of TCL_GLOBAL_ONLY,
* TCL_LEAVE_ERR_MSG, and PART1_NOT_PARSED
* bits. */
{
Var *varPtr, *arrayPtr;
Interp *iPtr = (Interp *) interp;
varPtr = LookupVar(interp, part1, part2, flags, "read", CRT_PART2,
&arrayPtr);
if (varPtr == NULL) {
return NULL;
}
/*
* Invoke any traces that have been set for the variable.
*/
if ((varPtr->tracePtr != NULL)
|| ((arrayPtr != NULL) && (arrayPtr->tracePtr != NULL))) {
char *msg;
msg = CallTraces(iPtr, arrayPtr, varPtr, part1, part2,
(flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED)) | TCL_TRACE_READS);
if (msg != NULL) {
VarErrMsg(interp, part1, part2, "read", msg);
goto cleanup;
}
}
if (!(varPtr->flags & (VAR_UNDEFINED|VAR_UPVAR|VAR_ARRAY))) {
return varPtr->value.string;
}
if (flags & TCL_LEAVE_ERR_MSG) {
char *msg;
if ((varPtr->flags & VAR_UNDEFINED) && (arrayPtr != NULL)
&& !(arrayPtr->flags & VAR_UNDEFINED)) {
msg = noSuchElement;
} else if (varPtr->flags & VAR_ARRAY) {
msg = isArray;
} else {
msg = noSuchVar;
}
VarErrMsg(interp, part1, part2, "read", msg);
}
/*
* If the variable doesn't exist anymore and no-one's using it,
* then free up the relevant structures and hash table entries.
*/
cleanup:
if (varPtr->flags & VAR_UNDEFINED) {
CleanupVar(varPtr, arrayPtr);
}
return NULL;
}
/*
*----------------------------------------------------------------------
*
* Tcl_SetVar --
*
* Change the value of a variable.
*
* Results:
* Returns a pointer to the malloc'ed string holding the new
* value of the variable. The caller should not modify this
* string. If the write operation was disallowed then NULL
* is returned; if the TCL_LEAVE_ERR_MSG flag is set, then
* an explanatory message will be left in interp->result.
*
* Side effects:
* If varName is defined as a local or global variable in interp,
* its value is changed to newValue. If varName isn't currently
* defined, then a new global variable by that name is created.
*
*----------------------------------------------------------------------
*/
char *
Tcl_SetVar(interp, varName, newValue, flags)
Tcl_Interp *interp; /* Command interpreter in which varName is
* to be looked up. */
char *varName; /* Name of a variable in interp. */
char *newValue; /* New value for varName. */
int flags; /* Various flags that tell how to set value:
* any of TCL_GLOBAL_ONLY, TCL_APPEND_VALUE,
* TCL_LIST_ELEMENT, or TCL_LEAVE_ERR_MSG. */
{
return Tcl_SetVar2(interp, varName, (char *) NULL, newValue,
flags | PART1_NOT_PARSED);
}
/*
*----------------------------------------------------------------------
*
* Tcl_SetVar2 --
*
* Given a two-part variable name, which may refer either to a
* scalar variable or an element of an array, change the value
* of the variable. If the named scalar or array or element
* doesn't exist then create one.
*
* Results:
* Returns a pointer to the malloc'ed string holding the new
* value of the variable. The caller should not modify this
* string. If the write operation was disallowed because an
* array was expected but not found (or vice versa), then NULL
* is returned; if the TCL_LEAVE_ERR_MSG flag is set, then
* an explanatory message will be left in interp->result.
*
* Side effects:
* The value of the given variable is set. If either the array
* or the entry didn't exist then a new one is created.
*
*----------------------------------------------------------------------
*/
char *
Tcl_SetVar2(interp, part1, part2, newValue, flags)
Tcl_Interp *interp; /* Command interpreter in which variable is
* to be looked up. */
char *part1; /* If part2 is NULL, this is name of scalar
* variable. Otherwise it is name of array. */
char *part2; /* Name of an element within array, or NULL. */
char *newValue; /* New value for variable. */
int flags; /* Various flags that tell how to set value:
* any of TCL_GLOBAL_ONLY, TCL_APPEND_VALUE,
* TCL_LIST_ELEMENT, TCL_LEAVE_ERR_MSG, or
* PART1_NOT_PARSED. */
{
register Var *varPtr;
register Interp *iPtr = (Interp *) interp;
int length, listFlags;
Var *arrayPtr;
char *result;
varPtr = LookupVar(interp, part1, part2, flags, "set", CRT_PART1|CRT_PART2,
&arrayPtr);
if (varPtr == NULL) {
return NULL;
}
/*
* If the variable's hPtr field is NULL, it means that this is an
* upvar to an array element where the array was deleted, leaving
* the element dangling at the end of the upvar. Generate an error
* (allowing the variable to be reset would screw up our storage
* allocation and is meaningless anyway).
*/
if (varPtr->hPtr == NULL) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, "set", danglingUpvar);
}
return NULL;
}
/*
* Clear the variable's current value unless this is an
* append operation.
*/
if (varPtr->flags & VAR_ARRAY) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, "set", isArray);
}
return NULL;
}
if (!(flags & TCL_APPEND_VALUE) || (varPtr->flags & VAR_UNDEFINED)) {
varPtr->valueLength = 0;
}
/*
* Call read trace if variable is being appended to.
*/
if ((flags & TCL_APPEND_VALUE) && ((varPtr->tracePtr != NULL)
|| ((arrayPtr != NULL) && (arrayPtr->tracePtr != NULL)))) {
char *msg;
msg = CallTraces(iPtr, arrayPtr, varPtr, part1, part2,
(flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED))|TCL_TRACE_READS);
if (msg != NULL) {
VarErrMsg(interp, part1, part2, "read", msg);
result = NULL;
goto cleanup;
}
}
/*
* Ensure that the new value is not NULL; if it is, replace it with "".
*/
if (newValue == (char *) NULL) {
newValue = "";
}
/*
* Compute how many total bytes will be needed for the variable's
* new value (leave space for a separating space between list
* elements). Allocate new space for the value if needed.
*/
if (flags & TCL_LIST_ELEMENT) {
length = Tcl_ScanElement(newValue, &listFlags) + 1;
} else {
length = strlen(newValue);
}
length += varPtr->valueLength;
if (length >= varPtr->valueSpace) {
char *newValue;
int newSize;
newSize = 2*varPtr->valueSpace;
if (newSize <= length) {
newSize = length + 1;
}
if (newSize < 24) {
/*
* Don't waste time with teensy-tiny variables; we'll
* just end up expanding them later.
*/
newSize = 24;
}
newValue = (char *) ckalloc((unsigned) newSize);
if (varPtr->valueSpace > 0) {
strcpy(newValue, varPtr->value.string);
ckfree(varPtr->value.string);
}
varPtr->valueSpace = newSize;
varPtr->value.string = newValue;
}
/*
* Append the new value to the variable, either as a list
* element or as a string.
*/
if (flags & TCL_LIST_ELEMENT) {
char *dst = varPtr->value.string + varPtr->valueLength;
if (TclNeedSpace(varPtr->value.string, dst)) {
*dst = ' ';
dst++;
varPtr->valueLength++;
}
varPtr->valueLength += Tcl_ConvertElement(newValue, dst, listFlags);
} else {
strcpy(varPtr->value.string + varPtr->valueLength, newValue);
varPtr->valueLength = length;
}
varPtr->flags &= ~VAR_UNDEFINED;
/*
* Invoke any write traces for the variable.
*/
if ((varPtr->tracePtr != NULL)
|| ((arrayPtr != NULL) && (arrayPtr->tracePtr != NULL))) {
char *msg;
msg = CallTraces(iPtr, arrayPtr, varPtr, part1, part2,
(flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED))
| TCL_TRACE_WRITES);
if (msg != NULL) {
VarErrMsg(interp, part1, part2, "set", msg);
result = NULL;
goto cleanup;
}
}
/*
* If the variable was changed in some gross way by a trace (e.g.
* it was unset and then recreated as an array) then just return
* an empty string; otherwise return the variable's current
* value.
*/
if (!(varPtr->flags & (VAR_UNDEFINED|VAR_UPVAR|VAR_ARRAY))) {
return varPtr->value.string;
}
result = "";
/*
* If the variable doesn't exist anymore and no-one's using it,
* then free up the relevant structures and hash table entries.
*/
cleanup:
if (varPtr->flags & VAR_UNDEFINED) {
CleanupVar(varPtr, arrayPtr);
}
return result;
}
/*
*----------------------------------------------------------------------
*
* Tcl_UnsetVar --
*
* Delete a variable, so that it may not be accessed anymore.
*
* Results:
* Returns TCL_OK if the variable was successfully deleted, TCL_ERROR
* if the variable can't be unset. In the event of an error,
* if the TCL_LEAVE_ERR_MSG flag is set then an error message
* is left in interp->result.
*
* Side effects:
* If varName is defined as a local or global variable in interp,
* it is deleted.
*
*----------------------------------------------------------------------
*/
int
Tcl_UnsetVar(interp, varName, flags)
Tcl_Interp *interp; /* Command interpreter in which varName is
* to be looked up. */
char *varName; /* Name of a variable in interp. May be
* either a scalar name or an array name
* or an element in an array. */
int flags; /* OR-ed combination of any of
* TCL_GLOBAL_ONLY or TCL_LEAVE_ERR_MSG. */
{
return Tcl_UnsetVar2(interp, varName, (char *) NULL,
flags | PART1_NOT_PARSED);
}
/*
*----------------------------------------------------------------------
*
* Tcl_UnsetVar2 --
*
* Delete a variable, given a 2-part name.
*
* Results:
* Returns TCL_OK if the variable was successfully deleted, TCL_ERROR
* if the variable can't be unset. In the event of an error,
* if the TCL_LEAVE_ERR_MSG flag is set then an error message
* is left in interp->result.
*
* Side effects:
* If part1 and part2 indicate a local or global variable in interp,
* it is deleted. If part1 is an array name and part2 is NULL, then
* the whole array is deleted.
*
*----------------------------------------------------------------------
*/
int
Tcl_UnsetVar2(interp, part1, part2, flags)
Tcl_Interp *interp; /* Command interpreter in which varName is
* to be looked up. */
char *part1; /* Name of variable or array. */
char *part2; /* Name of element within array or NULL. */
int flags; /* OR-ed combination of any of
* TCL_GLOBAL_ONLY, TCL_LEAVE_ERR_MSG,
* or PART1_NOT_PARSED. */
{
Var *varPtr, dummyVar;
Interp *iPtr = (Interp *) interp;
Var *arrayPtr;
ActiveVarTrace *activePtr;
int result;
varPtr = LookupVar(interp, part1, part2, flags, "unset", 0, &arrayPtr);
if (varPtr == NULL) {
return TCL_ERROR;
}
result = (varPtr->flags & VAR_UNDEFINED) ? TCL_ERROR : TCL_OK;
if ((arrayPtr != NULL) && (arrayPtr->searchPtr != NULL)) {
DeleteSearches(arrayPtr);
}
/*
* The code below is tricky, because of the possibility that
* a trace procedure might try to access a variable being
* deleted. To handle this situation gracefully, do things
* in three steps:
* 1. Copy the contents of the variable to a dummy variable
* structure, and mark the original structure as undefined.
* 2. Invoke traces and clean up the variable, using the copy.
* 3. If at the end of this the original variable is still
* undefined and has no outstanding references, then delete
* it (but it could have gotten recreated by a trace).
*/
dummyVar = *varPtr;
varPtr->valueSpace = 0;
varPtr->flags = VAR_UNDEFINED;
varPtr->tracePtr = NULL;
varPtr->searchPtr = NULL;
/*
* Call trace procedures for the variable being deleted and delete
* its traces. Be sure to abort any other traces for the variable
* that are still pending. Special tricks:
* 1. Increment varPtr's refCount around this: CallTraces will
* use dummyVar so it won't increment varPtr's refCount.
* 2. Turn off the VAR_TRACE_ACTIVE flag in dummyVar: we want to
* call unset traces even if other traces are pending.
*/
if ((dummyVar.tracePtr != NULL)
|| ((arrayPtr != NULL) && (arrayPtr->tracePtr != NULL))) {
varPtr->refCount++;
dummyVar.flags &= ~VAR_TRACE_ACTIVE;
(void) CallTraces(iPtr, arrayPtr, &dummyVar, part1, part2,
(flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED))
| TCL_TRACE_UNSETS);
while (dummyVar.tracePtr != NULL) {
VarTrace *tracePtr = dummyVar.tracePtr;
dummyVar.tracePtr = tracePtr->nextPtr;
ckfree((char *) tracePtr);
}
for (activePtr = iPtr->activeTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == varPtr) {
activePtr->nextTracePtr = NULL;
}
}
varPtr->refCount--;
}
/*
* If the variable is an array, delete all of its elements. This
* must be done after calling the traces on the array, above (that's
* the way traces are defined).
*/
if (dummyVar.flags & VAR_ARRAY) {
DeleteArray(iPtr, part1, &dummyVar,
(flags & TCL_GLOBAL_ONLY) | TCL_TRACE_UNSETS);
}
if (dummyVar.valueSpace > 0) {
ckfree(dummyVar.value.string);
}
if (result == TCL_ERROR) {
if (flags & TCL_LEAVE_ERR_MSG) {
VarErrMsg(interp, part1, part2, "unset",
(arrayPtr == NULL) ? noSuchVar : noSuchElement);
}
}
/*
* Finally, if the variable is truly not in use then free up its
* record and remove it from the hash table.
*/
CleanupVar(varPtr, arrayPtr);
return result;
}
/*
*----------------------------------------------------------------------
*
* Tcl_TraceVar --
*
* Arrange for reads and/or writes to a variable to cause a
* procedure to be invoked, which can monitor the operations
* and/or change their actions.
*
* Results:
* A standard Tcl return value.
*
* Side effects:
* A trace is set up on the variable given by varName, such that
* future references to the variable will be intermediated by
* proc. See the manual entry for complete details on the calling
* sequence for proc.
*
*----------------------------------------------------------------------
*/
int
Tcl_TraceVar(interp, varName, flags, proc, clientData)
Tcl_Interp *interp; /* Interpreter in which variable is
* to be traced. */
char *varName; /* Name of variable; may end with "(index)"
* to signify an array reference. */
int flags; /* OR-ed collection of bits, including any
* of TCL_TRACE_READS, TCL_TRACE_WRITES,
* TCL_TRACE_UNSETS, and TCL_GLOBAL_ONLY. */
Tcl_VarTraceProc *proc; /* Procedure to call when specified ops are
* invoked upon varName. */
ClientData clientData; /* Arbitrary argument to pass to proc. */
{
return Tcl_TraceVar2(interp, varName, (char *) NULL,
flags | PART1_NOT_PARSED, proc, clientData);
}
/*
*----------------------------------------------------------------------
*
* Tcl_TraceVar2 --
*
* Arrange for reads and/or writes to a variable to cause a
* procedure to be invoked, which can monitor the operations
* and/or change their actions.
*
* Results:
* A standard Tcl return value.
*
* Side effects:
* A trace is set up on the variable given by part1 and part2, such
* that future references to the variable will be intermediated by
* proc. See the manual entry for complete details on the calling
* sequence for proc.
*
*----------------------------------------------------------------------
*/
int
Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData)
Tcl_Interp *interp; /* Interpreter in which variable is
* to be traced. */
char *part1; /* Name of scalar variable or array. */
char *part2; /* Name of element within array; NULL means
* trace applies to scalar variable or array
* as-a-whole. */
int flags; /* OR-ed collection of bits, including any
* of TCL_TRACE_READS, TCL_TRACE_WRITES,
* TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, and
* PART1_NOT_PARSED. */
Tcl_VarTraceProc *proc; /* Procedure to call when specified ops are
* invoked upon varName. */
ClientData clientData; /* Arbitrary argument to pass to proc. */
{
Var *varPtr, *arrayPtr;
register VarTrace *tracePtr;
varPtr = LookupVar(interp, part1, part2, (flags | TCL_LEAVE_ERR_MSG),
"trace", CRT_PART1|CRT_PART2, &arrayPtr);
if (varPtr == NULL) {
return TCL_ERROR;
}
/*
* Set up trace information.
*/
tracePtr = (VarTrace *) ckalloc(sizeof(VarTrace));
tracePtr->traceProc = proc;
tracePtr->clientData = clientData;
tracePtr->flags = flags &
(TCL_TRACE_READS|TCL_TRACE_WRITES|TCL_TRACE_UNSETS);
tracePtr->nextPtr = varPtr->tracePtr;
varPtr->tracePtr = tracePtr;
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_UntraceVar --
*
* Remove a previously-created trace for a variable.
*
* Results:
* None.
*
* Side effects:
* If there exists a trace for the variable given by varName
* with the given flags, proc, and clientData, then that trace
* is removed.
*
*----------------------------------------------------------------------
*/
void
Tcl_UntraceVar(interp, varName, flags, proc, clientData)
Tcl_Interp *interp; /* Interpreter containing traced variable. */
char *varName; /* Name of variable; may end with "(index)"
* to signify an array reference. */
int flags; /* OR-ed collection of bits describing
* current trace, including any of
* TCL_TRACE_READS, TCL_TRACE_WRITES,
* TCL_TRACE_UNSETS, and TCL_GLOBAL_ONLY. */
Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */
ClientData clientData; /* Arbitrary argument to pass to proc. */
{
Tcl_UntraceVar2(interp, varName, (char *) NULL, flags | PART1_NOT_PARSED,
proc, clientData);
}
/*
*----------------------------------------------------------------------
*
* Tcl_UntraceVar2 --
*
* Remove a previously-created trace for a variable.
*
* Results:
* None.
*
* Side effects:
* If there exists a trace for the variable given by part1
* and part2 with the given flags, proc, and clientData, then
* that trace is removed.
*
*----------------------------------------------------------------------
*/
void
Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData)
Tcl_Interp *interp; /* Interpreter containing traced variable. */
char *part1; /* Name of variable or array. */
char *part2; /* Name of element within array; NULL means
* trace applies to scalar variable or array
* as-a-whole. */
int flags; /* OR-ed collection of bits describing
* current trace, including any of
* TCL_TRACE_READS, TCL_TRACE_WRITES,
* TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, and
* PART1_NOT_PARSED. */
Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */
ClientData clientData; /* Arbitrary argument to pass to proc. */
{
register VarTrace *tracePtr;
VarTrace *prevPtr;
Var *varPtr, *arrayPtr;
Interp *iPtr = (Interp *) interp;
ActiveVarTrace *activePtr;
varPtr = LookupVar(interp, part1, part2,
flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED), (char *) NULL, 0,
&arrayPtr);
if (varPtr == NULL) {
return;
}
flags &= (TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS);
for (tracePtr = varPtr->tracePtr, prevPtr = NULL; ;
prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) {
if (tracePtr == NULL) {
return;
}
if ((tracePtr->traceProc == proc) && (tracePtr->flags == flags)
&& (tracePtr->clientData == clientData)) {
break;
}
}
/*
* The code below makes it possible to delete traces while traces
* are active: it makes sure that the deleted trace won't be
* processed by CallTraces.
*/
for (activePtr = iPtr->activeTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->nextTracePtr == tracePtr) {
activePtr->nextTracePtr = tracePtr->nextPtr;
}
}
if (prevPtr == NULL) {
varPtr->tracePtr = tracePtr->nextPtr;
} else {
prevPtr->nextPtr = tracePtr->nextPtr;
}
ckfree((char *) tracePtr);
/*
* If this is the last trace on the variable, and the variable is
* unset and unused, then free up the variable.
*/
if (varPtr->flags & VAR_UNDEFINED) {
CleanupVar(varPtr, (Var *) NULL);
}
}
/*
*----------------------------------------------------------------------
*
* Tcl_VarTraceInfo --
*
* Return the clientData value associated with a trace on a
* variable. This procedure can also be used to step through
* all of the traces on a particular variable that have the
* same trace procedure.
*
* Results:
* The return value is the clientData value associated with
* a trace on the given variable. Information will only be
* returned for a trace with proc as trace procedure. If
* the clientData argument is NULL then the first such trace is
* returned; otherwise, the next relevant one after the one
* given by clientData will be returned. If the variable
* doesn't exist, or if there are no (more) traces for it,
* then NULL is returned.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
ClientData
Tcl_VarTraceInfo(interp, varName, flags, proc, prevClientData)
Tcl_Interp *interp; /* Interpreter containing variable. */
char *varName; /* Name of variable; may end with "(index)"
* to signify an array reference. */
int flags; /* 0 or TCL_GLOBAL_ONLY. */
Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */
ClientData prevClientData; /* If non-NULL, gives last value returned
* by this procedure, so this call will
* return the next trace after that one.
* If NULL, this call will return the
* first trace. */
{
return Tcl_VarTraceInfo2(interp, varName, (char *) NULL,
flags | PART1_NOT_PARSED, proc, prevClientData);
}
/*
*----------------------------------------------------------------------
*
* Tcl_VarTraceInfo2 --
*
* Same as Tcl_VarTraceInfo, except takes name in two pieces
* instead of one.
*
* Results:
* Same as Tcl_VarTraceInfo.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
ClientData
Tcl_VarTraceInfo2(interp, part1, part2, flags, proc, prevClientData)
Tcl_Interp *interp; /* Interpreter containing variable. */
char *part1; /* Name of variable or array. */
char *part2; /* Name of element within array; NULL means
* trace applies to scalar variable or array
* as-a-whole. */
int flags; /* OR-ed combination of TCL_GLOBAL_ONLY and
* PART1_NOT_PARSED. */
Tcl_VarTraceProc *proc; /* Procedure assocated with trace. */
ClientData prevClientData; /* If non-NULL, gives last value returned
* by this procedure, so this call will
* return the next trace after that one.
* If NULL, this call will return the
* first trace. */
{
register VarTrace *tracePtr;
Var *varPtr, *arrayPtr;
varPtr = LookupVar(interp, part1, part2,
flags & (TCL_GLOBAL_ONLY|PART1_NOT_PARSED), (char *) NULL, 0,
&arrayPtr);
if (varPtr == NULL) {
return NULL;
}
/*
* Find the relevant trace, if any, and return its clientData.
*/
tracePtr = varPtr->tracePtr;
if (prevClientData != NULL) {
for ( ; tracePtr != NULL; tracePtr = tracePtr->nextPtr) {
if ((tracePtr->clientData == prevClientData)
&& (tracePtr->traceProc == proc)) {
tracePtr = tracePtr->nextPtr;
break;
}
}
}
for ( ; tracePtr != NULL; tracePtr = tracePtr->nextPtr) {
if (tracePtr->traceProc == proc) {
return tracePtr->clientData;
}
}
return NULL;
}
/*
*----------------------------------------------------------------------
*
* Tcl_SetCmd --
*
* This procedure is invoked to process the "set" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* A variable's value may be changed.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_SetCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
register Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
if (argc == 2) {
char *value;
value = Tcl_GetVar2(interp, argv[1], (char *) NULL,
TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED);
if (value == NULL) {
return TCL_ERROR;
}
interp->result = value;
return TCL_OK;
} else if (argc == 3) {
char *result;
result = Tcl_SetVar2(interp, argv[1], (char *) NULL, argv[2],
TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED);
if (result == NULL) {
return TCL_ERROR;
}
interp->result = result;
return TCL_OK;
} else {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " varName ?newValue?\"", (char *) NULL);
return TCL_ERROR;
}
}
/*
*----------------------------------------------------------------------
*
* Tcl_UnsetCmd --
*
* This procedure is invoked to process the "unset" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_UnsetCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
register Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
int i;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " varName ?varName ...?\"", (char *) NULL);
return TCL_ERROR;
}
for (i = 1; i < argc; i++) {
if (Tcl_UnsetVar2(interp, argv[i], (char *) NULL,
TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED) != TCL_OK) {
return TCL_ERROR;
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_AppendCmd --
*
* This procedure is invoked to process the "append" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* A variable's value may be changed.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_AppendCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
register Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
int i;
char *result = NULL; /* (Initialization only needed to keep
* the compiler from complaining) */
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " varName ?value value ...?\"", (char *) NULL);
return TCL_ERROR;
}
if (argc == 2) {
result = Tcl_GetVar2(interp, argv[1], (char *) NULL,
TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED);
if (result == NULL) {
return TCL_ERROR;
}
interp->result = result;
return TCL_OK;
}
for (i = 2; i < argc; i++) {
result = Tcl_SetVar2(interp, argv[1], (char *) NULL, argv[i],
TCL_APPEND_VALUE|TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED);
if (result == NULL) {
return TCL_ERROR;
}
}
interp->result = result;
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_LappendCmd --
*
* This procedure is invoked to process the "lappend" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* A variable's value may be changed.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_LappendCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
register Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
int i;
char *result = NULL; /* (Initialization only needed to keep
* the compiler from complaining) */
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " varName ?value value ...?\"", (char *) NULL);
return TCL_ERROR;
}
if (argc == 2) {
result = Tcl_GetVar2(interp, argv[1], (char *) NULL,
TCL_LEAVE_ERR_MSG|PART1_NOT_PARSED);
if (result == NULL) {
return TCL_ERROR;
}
interp->result = result;
return TCL_OK;
}
for (i = 2; i < argc; i++) {
result = Tcl_SetVar2(interp, argv[1], (char *) NULL, argv[i],
TCL_APPEND_VALUE|TCL_LIST_ELEMENT|TCL_LEAVE_ERR_MSG
|PART1_NOT_PARSED);
if (result == NULL) {
return TCL_ERROR;
}
}
interp->result = result;
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_ArrayCmd --
*
* This procedure is invoked to process the "array" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_ArrayCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
register Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
int c, notArray;
size_t length;
Var *varPtr = NULL; /* Initialization needed only to prevent
* compiler warning. */
Tcl_HashEntry *hPtr;
Interp *iPtr = (Interp *) interp;
if (argc < 3) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " option arrayName ?arg ...?\"", (char *) NULL);
return TCL_ERROR;
}
/*
* Locate the array variable (and it better be an array).
*/
if (iPtr->varFramePtr == NULL) {
hPtr = Tcl_FindHashEntry(&iPtr->globalTable, argv[2]);
} else {
hPtr = Tcl_FindHashEntry(&iPtr->varFramePtr->varTable, argv[2]);
}
notArray = 0;
if (hPtr == NULL) {
notArray = 1;
} else {
varPtr = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr->flags & VAR_UPVAR) {
varPtr = varPtr->value.upvarPtr;
}
if (!(varPtr->flags & VAR_ARRAY)) {
notArray = 1;
}
}
/*
* Dispatch based on the option.
*/
c = argv[1][0];
length = strlen(argv[1]);
if ((c == 'a') && (strncmp(argv[1], "anymore", length) == 0)) {
ArraySearch *searchPtr;
if (argc != 4) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " anymore arrayName searchId\"", (char *) NULL);
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, argv[2], argv[3]);
if (searchPtr == NULL) {
return TCL_ERROR;
}
while (1) {
Var *varPtr2;
if (searchPtr->nextEntry != NULL) {
varPtr2 = (Var *) Tcl_GetHashValue(searchPtr->nextEntry);
if (!(varPtr2->flags & VAR_UNDEFINED)) {
break;
}
}
searchPtr->nextEntry = Tcl_NextHashEntry(&searchPtr->search);
if (searchPtr->nextEntry == NULL) {
interp->result = "0";
return TCL_OK;
}
}
interp->result = "1";
return TCL_OK;
} else if ((c == 'd') && (strncmp(argv[1], "donesearch", length) == 0)) {
ArraySearch *searchPtr, *prevPtr;
if (argc != 4) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " donesearch arrayName searchId\"", (char *) NULL);
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, argv[2], argv[3]);
if (searchPtr == NULL) {
return TCL_ERROR;
}
if (varPtr->searchPtr == searchPtr) {
varPtr->searchPtr = searchPtr->nextPtr;
} else {
for (prevPtr = varPtr->searchPtr; ; prevPtr = prevPtr->nextPtr) {
if (prevPtr->nextPtr == searchPtr) {
prevPtr->nextPtr = searchPtr->nextPtr;
break;
}
}
}
ckfree((char *) searchPtr);
} else if ((c == 'e') && (strncmp(argv[1], "exists", length) == 0)) {
if (argc != 3) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " exists arrayName\"", (char *) NULL);
return TCL_ERROR;
}
interp->result = (notArray) ? "0" : "1";
} else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) {
Tcl_HashSearch search;
Var *varPtr2;
char *name;
if ((argc != 3) && (argc != 4)) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " get arrayName ?pattern?\"", (char *) NULL);
return TCL_ERROR;
}
if (notArray) {
return TCL_OK;
}
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr2->flags & VAR_UNDEFINED) {
continue;
}
name = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
if ((argc == 4) && !Tcl_StringMatch(name, argv[3])) {
continue;
}
Tcl_AppendElement(interp, name);
Tcl_AppendElement(interp, varPtr2->value.string);
}
} else if ((c == 'n') && (strncmp(argv[1], "names", length) == 0)
&& (length >= 2)) {
Tcl_HashSearch search;
Var *varPtr2;
char *name;
if ((argc != 3) && (argc != 4)) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " names arrayName ?pattern?\"", (char *) NULL);
return TCL_ERROR;
}
if (notArray) {
return TCL_OK;
}
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr2->flags & VAR_UNDEFINED) {
continue;
}
name = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
if ((argc == 4) && !Tcl_StringMatch(name, argv[3])) {
continue;
}
Tcl_AppendElement(interp, name);
}
} else if ((c == 'n') && (strncmp(argv[1], "nextelement", length) == 0)
&& (length >= 2)) {
ArraySearch *searchPtr;
Tcl_HashEntry *hPtr;
if (argc != 4) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " nextelement arrayName searchId\"",
(char *) NULL);
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, argv[2], argv[3]);
if (searchPtr == NULL) {
return TCL_ERROR;
}
while (1) {
Var *varPtr2;
hPtr = searchPtr->nextEntry;
if (hPtr == NULL) {
hPtr = Tcl_NextHashEntry(&searchPtr->search);
if (hPtr == NULL) {
return TCL_OK;
}
} else {
searchPtr->nextEntry = NULL;
}
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (!(varPtr2->flags & VAR_UNDEFINED)) {
break;
}
}
interp->result = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
} else if ((c == 's') && (strncmp(argv[1], "set", length) == 0)
&& (length >= 2)) {
char **valueArgv;
int valueArgc, i, result;
if (argc != 4) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " set arrayName list\"", (char *) NULL);
return TCL_ERROR;
}
if (Tcl_SplitList(interp, argv[3], &valueArgc, &valueArgv) != TCL_OK) {
return TCL_ERROR;
}
result = TCL_OK;
if (valueArgc & 1) {
interp->result = "list must have an even number of elements";
result = TCL_ERROR;
goto setDone;
}
for (i = 0; i < valueArgc; i += 2) {
if (Tcl_SetVar2(interp, argv[2], valueArgv[i], valueArgv[i+1],
TCL_LEAVE_ERR_MSG) == NULL) {
result = TCL_ERROR;
break;
}
}
setDone:
ckfree((char *) valueArgv);
return result;
} else if ((c == 's') && (strncmp(argv[1], "size", length) == 0)
&& (length >= 2)) {
Tcl_HashSearch search;
Var *varPtr2;
int size;
if (argc != 3) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " size arrayName\"", (char *) NULL);
return TCL_ERROR;
}
size = 0;
if (!notArray) {
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr2->flags & VAR_UNDEFINED) {
continue;
}
size++;
}
}
sprintf(interp->result, "%d", size);
} else if ((c == 's') && (strncmp(argv[1], "startsearch", length) == 0)
&& (length >= 2)) {
ArraySearch *searchPtr;
if (argc != 3) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " startsearch arrayName\"", (char *) NULL);
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = (ArraySearch *) ckalloc(sizeof(ArraySearch));
if (varPtr->searchPtr == NULL) {
searchPtr->id = 1;
Tcl_AppendResult(interp, "s-1-", argv[2], (char *) NULL);
} else {
char string[20];
searchPtr->id = varPtr->searchPtr->id + 1;
sprintf(string, "%d", searchPtr->id);
Tcl_AppendResult(interp, "s-", string, "-", argv[2],
(char *) NULL);
}
searchPtr->varPtr = varPtr;
searchPtr->nextEntry = Tcl_FirstHashEntry(varPtr->value.tablePtr,
&searchPtr->search);
searchPtr->nextPtr = varPtr->searchPtr;
varPtr->searchPtr = searchPtr;
} else {
Tcl_AppendResult(interp, "bad option \"", argv[1],
"\": should be anymore, donesearch, exists, ",
"get, names, nextelement, ",
"set, size, or startsearch", (char *) NULL);
return TCL_ERROR;
}
return TCL_OK;
error:
Tcl_AppendResult(interp, "\"", argv[2], "\" isn't an array",
(char *) NULL);
return TCL_ERROR;
}
/*
*----------------------------------------------------------------------
*
* MakeUpvar --
*
* This procedure does all of the work of the "global" and "upvar"
* commands.
*
* Results:
* A standard Tcl completion code. If an error occurs then an
* error message is left in iPtr->result.
*
* Side effects:
* The variable given by myName is linked to the variable in
* framePtr given by otherP1 and otherP2, so that references to
* myName are redirected to the other variable like a symbolic
* link.
*
*----------------------------------------------------------------------
*/
static int
MakeUpvar(iPtr, framePtr, otherP1, otherP2, myName, flags)
Interp *iPtr; /* Interpreter containing variables. Used
* for error messages, too. */
CallFrame *framePtr; /* Call frame containing "other" variable.
* NULL means use global context. */
char *otherP1, *otherP2; /* Two-part name of variable in framePtr. */
char *myName; /* Name of variable in local table, which
* will refer to otherP1/P2. Must be a
* scalar. */
int flags; /* 0 or TCL_GLOBAL_ONLY: indicates scope of
* myName. */
{
Tcl_HashEntry *hPtr;
Var *otherPtr, *varPtr, *arrayPtr;
CallFrame *savedFramePtr;
int new;
/*
* In order to use LookupVar to find "other", temporarily replace
* the current frame pointer in the interpreter.
*/
savedFramePtr = iPtr->varFramePtr;
iPtr->varFramePtr = framePtr;
otherPtr = LookupVar((Tcl_Interp *) iPtr, otherP1, otherP2,
TCL_LEAVE_ERR_MSG, "access", CRT_PART1|CRT_PART2, &arrayPtr);
iPtr->varFramePtr = savedFramePtr;
if (otherPtr == NULL) {
return TCL_ERROR;
}
if ((flags & TCL_GLOBAL_ONLY) || (iPtr->varFramePtr == NULL)) {
hPtr = Tcl_CreateHashEntry(&iPtr->globalTable, myName, &new);
} else {
hPtr = Tcl_CreateHashEntry(&iPtr->varFramePtr->varTable, myName, &new);
}
if (new) {
varPtr = NewVar();
Tcl_SetHashValue(hPtr, varPtr);
varPtr->hPtr = hPtr;
} else {
/*
* The variable already exists. Make sure that this variable
* isn't also "otherVar" (avoid circular links). Also, if it's
* not an upvar then it's an error. If it is an upvar, then
* just disconnect it from the thing it currently refers to.
*/
varPtr = (Var *) Tcl_GetHashValue(hPtr);
if (varPtr == otherPtr) {
iPtr->result = "can't upvar from variable to itself";
return TCL_ERROR;
}
if (varPtr->flags & VAR_UPVAR) {
Var *upvarPtr;
upvarPtr = varPtr->value.upvarPtr;
if (upvarPtr == otherPtr) {
return TCL_OK;
}
upvarPtr->refCount--;
if (upvarPtr->flags & VAR_UNDEFINED) {
CleanupVar(upvarPtr, (Var *) NULL);
}
} else if (!(varPtr->flags & VAR_UNDEFINED)) {
Tcl_AppendResult((Tcl_Interp *) iPtr, "variable \"", myName,
"\" already exists", (char *) NULL);
return TCL_ERROR;
} else if (varPtr->tracePtr != NULL) {
Tcl_AppendResult((Tcl_Interp *) iPtr, "variable \"", myName,
"\" has traces: can't use for upvar", (char *) NULL);
return TCL_ERROR;
}
}
varPtr->flags = (varPtr->flags & ~VAR_UNDEFINED) | VAR_UPVAR;
varPtr->value.upvarPtr = otherPtr;
otherPtr->refCount++;
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_UpVar --
*
* This procedure links one variable to another, just like
* the "upvar" command.
*
* Results:
* A standard Tcl completion code. If an error occurs then
* an error message is left in interp->result.
*
* Side effects:
* The variable in frameName whose name is given by varName becomes
* accessible under the name localName, so that references to
* localName are redirected to the other variable like a symbolic
* link.
*
*----------------------------------------------------------------------
*/
int
Tcl_UpVar(interp, frameName, varName, localName, flags)
Tcl_Interp *interp; /* Command interpreter in which varName is
* to be looked up. */
char *frameName; /* Name of the frame containing the source
* variable, such as "1" or "#0". */
char *varName; /* Name of a variable in interp. May be
* either a scalar name or an element
* in an array. */
char *localName; /* Destination variable name. */
int flags; /* Either 0 or TCL_GLOBAL_ONLY; indicates
* whether localName is local or global. */
{
int result;
CallFrame *framePtr;
register char *p;
result = TclGetFrame(interp, frameName, &framePtr);
if (result == -1) {
return TCL_ERROR;
}
/*
* Figure out whether this is an array reference, then call
* MakeUpvar to do all the real work.
*/
for (p = varName; *p != '\0'; p++) {
if (*p == '(') {
char *openParen = p;
do {
p++;
} while (*p != '\0');
p--;
if (*p != ')') {
goto scalar;
}
*openParen = '\0';
*p = '\0';
result = MakeUpvar((Interp *) interp, framePtr, varName,
openParen+1, localName, flags);
*openParen = '(';
*p = ')';
return result;
}
}
scalar:
return MakeUpvar((Interp *) interp, framePtr, varName, (char *) NULL,
localName, flags);
}
/*
*----------------------------------------------------------------------
*
* Tcl_UpVar2 --
*
* This procedure links one variable to another, just like
* the "upvar" command.
*
* Results:
* A standard Tcl completion code. If an error occurs then
* an error message is left in interp->result.
*
* Side effects:
* The variable in frameName whose name is given by part1 and
* part2 becomes accessible under the name localName, so that
* references to localName are redirected to the other variable
* like a symbolic link.
*
*----------------------------------------------------------------------
*/
int
Tcl_UpVar2(interp, frameName, part1, part2, localName, flags)
Tcl_Interp *interp; /* Interpreter containing variables. Used
* for error messages too. */
char *frameName; /* Name of the frame containing the source
* variable, such as "1" or "#0". */
char *part1, *part2; /* Two parts of source variable name. */
char *localName; /* Destination variable name. */
int flags; /* TCL_GLOBAL_ONLY or 0. */
{
int result;
CallFrame *framePtr;
result = TclGetFrame(interp, frameName, &framePtr);
if (result == -1) {
return TCL_ERROR;
}
return MakeUpvar((Interp *) interp, framePtr, part1, part2,
localName, flags);
}
/*
*----------------------------------------------------------------------
*
* Tcl_GlobalCmd --
*
* This procedure is invoked to process the "global" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_GlobalCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
register Interp *iPtr = (Interp *) interp;
if (argc < 2) {
Tcl_AppendResult((Tcl_Interp *) iPtr, "wrong # args: should be \"",
argv[0], " varName ?varName ...?\"", (char *) NULL);
return TCL_ERROR;
}
if (iPtr->varFramePtr == NULL) {
return TCL_OK;
}
for (argc--, argv++; argc > 0; argc--, argv++) {
if (MakeUpvar(iPtr, (CallFrame *) NULL, *argv, (char *) NULL, *argv, 0)
!= TCL_OK) {
return TCL_ERROR;
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_UpvarCmd --
*
* This procedure is invoked to process the "upvar" Tcl command.
* See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_UpvarCmd(dummy, interp, argc, argv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
register Interp *iPtr = (Interp *) interp;
int result;
CallFrame *framePtr;
register char *p;
if (argc < 3) {
upvarSyntax:
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
" ?level? otherVar localVar ?otherVar localVar ...?\"",
(char *) NULL);
return TCL_ERROR;
}
/*
* Find the hash table containing the variable being referenced.
*/
result = TclGetFrame(interp, argv[1], &framePtr);
if (result == -1) {
return TCL_ERROR;
}
argc -= result+1;
if ((argc & 1) != 0) {
goto upvarSyntax;
}
argv += result+1;
/*
* Iterate over all the pairs of (other variable, local variable)
* names. For each pair, divide the other variable name into two
* parts, then call MakeUpvar to do all the work of creating linking
* it to the local variable.
*/
for ( ; argc > 0; argc -= 2, argv += 2) {
for (p = argv[0]; *p != 0; p++) {
if (*p == '(') {
char *openParen = p;
do {
p++;
} while (*p != '\0');
p--;
if (*p != ')') {
goto scalar;
}
*openParen = '\0';
*p = '\0';
result = MakeUpvar(iPtr, framePtr, argv[0], openParen+1,
argv[1], 0);
*openParen = '(';
*p = ')';
goto checkResult;
}
}
scalar:
result = MakeUpvar(iPtr, framePtr, argv[0], (char *) NULL, argv[1], 0);
checkResult:
if (result != TCL_OK) {
return TCL_ERROR;
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* CallTraces --
*
* This procedure is invoked to find and invoke relevant
* trace procedures associated with a particular operation on
* a variable. This procedure invokes traces both on the
* variable and on its containing array (where relevant).
*
* Results:
* The return value is NULL if no trace procedures were invoked, or
* if all the invoked trace procedures returned successfully.
* The return value is non-zero if a trace procedure returned an
* error (in this case no more trace procedures were invoked after
* the error was returned). In this case the return value is a
* pointer to a static string describing the error.
*
* Side effects:
* Almost anything can happen, depending on trace; this procedure
* itself doesn't have any side effects.
*
*----------------------------------------------------------------------
*/
static char *
CallTraces(iPtr, arrayPtr, varPtr, part1, part2, flags)
Interp *iPtr; /* Interpreter containing variable. */
register Var *arrayPtr; /* Pointer to array variable that
* contains the variable, or NULL if
* the variable isn't an element of an
* array. */
Var *varPtr; /* Variable whose traces are to be
* invoked. */
char *part1, *part2; /* Variable's two-part name. */
int flags; /* Flags to pass to trace procedures:
* indicates what's happening to
* variable, plus other stuff like
* TCL_GLOBAL_ONLY and
* TCL_INTERP_DESTROYED. May also
* contain PART1_NOT_PARSEd, which
* should not be passed through
* to callbacks. */
{
register VarTrace *tracePtr;
ActiveVarTrace active;
char *result, *openParen, *p;
Tcl_DString nameCopy;
int copiedName;
/*
* If there are already similar trace procedures active for the
* variable, don't call them again.
*/
if (varPtr->flags & VAR_TRACE_ACTIVE) {
return NULL;
}
varPtr->flags |= VAR_TRACE_ACTIVE;
varPtr->refCount++;
/*
* If the variable name hasn't been parsed into array name and
* element, do it here. If there really is an array element,
* make a copy of the original name so that NULLs can be
* inserted into it to separate the names (can't modify the name
* string in place, because the string might get used by the
* callbacks we invoke).
*/
copiedName = 0;
if (flags & PART1_NOT_PARSED) {
for (p = part1; ; p++) {
if (*p == 0) {
break;
}
if (*p == '(') {
openParen = p;
do {
p++;
} while (*p != '\0');
p--;
if (*p == ')') {
Tcl_DStringInit(&nameCopy);
Tcl_DStringAppend(&nameCopy, part1, (p-part1));
part2 = Tcl_DStringValue(&nameCopy)
+ (openParen + 1 - part1);
part2[-1] = 0;
part1 = Tcl_DStringValue(&nameCopy);
copiedName = 1;
}
break;
}
}
}
flags &= ~PART1_NOT_PARSED;
/*
* Invoke traces on the array containing the variable, if relevant.
*/
result = NULL;
active.nextPtr = iPtr->activeTracePtr;
iPtr->activeTracePtr = &active;
if (arrayPtr != NULL) {
arrayPtr->refCount++;
active.varPtr = arrayPtr;
for (tracePtr = arrayPtr->tracePtr; tracePtr != NULL;
tracePtr = active.nextTracePtr) {
active.nextTracePtr = tracePtr->nextPtr;
if (!(tracePtr->flags & flags)) {
continue;
}
result = (*tracePtr->traceProc)(tracePtr->clientData,
(Tcl_Interp *) iPtr, part1, part2, flags);
if (result != NULL) {
if (flags & TCL_TRACE_UNSETS) {
result = NULL;
} else {
goto done;
}
}
}
}
/*
* Invoke traces on the variable itself.
*/
if (flags & TCL_TRACE_UNSETS) {
flags |= TCL_TRACE_DESTROYED;
}
active.varPtr = varPtr;
for (tracePtr = varPtr->tracePtr; tracePtr != NULL;
tracePtr = active.nextTracePtr) {
active.nextTracePtr = tracePtr->nextPtr;
if (!(tracePtr->flags & flags)) {
continue;
}
result = (*tracePtr->traceProc)(tracePtr->clientData,
(Tcl_Interp *) iPtr, part1, part2, flags);
if (result != NULL) {
if (flags & TCL_TRACE_UNSETS) {
result = NULL;
} else {
goto done;
}
}
}
/*
* Restore the variable's flags, remove the record of our active
* traces, and then return.
*/
done:
if (arrayPtr != NULL) {
arrayPtr->refCount--;
}
if (copiedName) {
Tcl_DStringFree(&nameCopy);
}
varPtr->flags &= ~VAR_TRACE_ACTIVE;
varPtr->refCount--;
iPtr->activeTracePtr = active.nextPtr;
return result;
}
/*
*----------------------------------------------------------------------
*
* NewVar --
*
* Create a new variable with a given amount of storage
* space.
*
* Results:
* The return value is a pointer to the new variable structure.
* The variable will not be part of any hash table yet. Its
* initial value is empty.
*
* Side effects:
* Storage gets allocated.
*
*----------------------------------------------------------------------
*/
static Var *
NewVar()
{
register Var *varPtr;
varPtr = (Var *) ckalloc(sizeof(Var));
varPtr->valueLength = 0;
varPtr->valueSpace = 0;
varPtr->value.string = NULL;
varPtr->hPtr = NULL;
varPtr->refCount = 0;
varPtr->tracePtr = NULL;
varPtr->searchPtr = NULL;
varPtr->flags = VAR_UNDEFINED;
return varPtr;
}
/*
*----------------------------------------------------------------------
*
* ParseSearchId --
*
* This procedure translates from a string to a pointer to an
* active array search (if there is one that matches the string).
*
* Results:
* The return value is a pointer to the array search indicated
* by string, or NULL if there isn't one. If NULL is returned,
* interp->result contains an error message.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static ArraySearch *
ParseSearchId(interp, varPtr, varName, string)
Tcl_Interp *interp; /* Interpreter containing variable. */
Var *varPtr; /* Array variable search is for. */
char *varName; /* Name of array variable that search is
* supposed to be for. */
char *string; /* String containing id of search. Must have
* form "search-num-var" where "num" is a
* decimal number and "var" is a variable
* name. */
{
char *end;
int id;
ArraySearch *searchPtr;
/*
* Parse the id into the three parts separated by dashes.
*/
if ((string[0] != 's') || (string[1] != '-')) {
syntax:
Tcl_AppendResult(interp, "illegal search identifier \"", string,
"\"", (char *) NULL);
return NULL;
}
id = strtoul(string+2, &end, 10);
if ((end == (string+2)) || (*end != '-')) {
goto syntax;
}
if (strcmp(end+1, varName) != 0) {
Tcl_AppendResult(interp, "search identifier \"", string,
"\" isn't for variable \"", varName, "\"", (char *) NULL);
return NULL;
}
/*
* Search through the list of active searches on the interpreter
* to see if the desired one exists.
*/
for (searchPtr = varPtr->searchPtr; searchPtr != NULL;
searchPtr = searchPtr->nextPtr) {
if (searchPtr->id == id) {
return searchPtr;
}
}
Tcl_AppendResult(interp, "couldn't find search \"", string, "\"",
(char *) NULL);
return NULL;
}
/*
*----------------------------------------------------------------------
*
* DeleteSearches --
*
* This procedure is called to free up all of the searches
* associated with an array variable.
*
* Results:
* None.
*
* Side effects:
* Memory is released to the storage allocator.
*
*----------------------------------------------------------------------
*/
static void
DeleteSearches(arrayVarPtr)
register Var *arrayVarPtr; /* Variable whose searches are
* to be deleted. */
{
ArraySearch *searchPtr;
while (arrayVarPtr->searchPtr != NULL) {
searchPtr = arrayVarPtr->searchPtr;
arrayVarPtr->searchPtr = searchPtr->nextPtr;
ckfree((char *) searchPtr);
}
}
/*
*----------------------------------------------------------------------
*
* TclDeleteVars --
*
* This procedure is called to recycle all the storage space
* associated with a table of variables. For this procedure
* to work correctly, it must not be possible for any of the
* variable in the table to be accessed from Tcl commands
* (e.g. from trace procedures).
*
* Results:
* None.
*
* Side effects:
* Variables are deleted and trace procedures are invoked, if
* any are declared.
*
*----------------------------------------------------------------------
*/
void
TclDeleteVars(iPtr, tablePtr)
Interp *iPtr; /* Interpreter to which variables belong. */
Tcl_HashTable *tablePtr; /* Hash table containing variables to
* delete. */
{
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
register Var *varPtr;
Var *upvarPtr;
int flags;
ActiveVarTrace *activePtr;
flags = TCL_TRACE_UNSETS;
if (tablePtr == &iPtr->globalTable) {
flags |= TCL_INTERP_DESTROYED | TCL_GLOBAL_ONLY;
}
for (hPtr = Tcl_FirstHashEntry(tablePtr, &search); hPtr != NULL;
hPtr = Tcl_NextHashEntry(&search)) {
varPtr = (Var *) Tcl_GetHashValue(hPtr);
/*
* For global/upvar variables referenced in procedures, decrement
* the reference count on the variable referred to, and free
* the referenced variable if it's no longer needed. Don't delete
* the hash entry for the other variable if it's in the same table
* as us: this will happen automatically later on.
*/
if (varPtr->flags & VAR_UPVAR) {
upvarPtr = varPtr->value.upvarPtr;
upvarPtr->refCount--;
if ((upvarPtr->refCount == 0) && (upvarPtr->flags & VAR_UNDEFINED)
&& (upvarPtr->tracePtr == NULL)) {
if (upvarPtr->hPtr == NULL) {
ckfree((char *) upvarPtr);
} else if (upvarPtr->hPtr->tablePtr != tablePtr) {
Tcl_DeleteHashEntry(upvarPtr->hPtr);
ckfree((char *) upvarPtr);
}
}
}
/*
* Invoke traces on the variable that is being deleted, then
* free up the variable's space (no need to free the hash entry
* here, unless we're dealing with a global variable: the
* hash entries will be deleted automatically when the whole
* table is deleted).
*/
if (varPtr->tracePtr != NULL) {
(void) CallTraces(iPtr, (Var *) NULL, varPtr,
Tcl_GetHashKey(tablePtr, hPtr), (char *) NULL, flags);
while (varPtr->tracePtr != NULL) {
VarTrace *tracePtr = varPtr->tracePtr;
varPtr->tracePtr = tracePtr->nextPtr;
ckfree((char *) tracePtr);
}
for (activePtr = iPtr->activeTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == varPtr) {
activePtr->nextTracePtr = NULL;
}
}
}
if (varPtr->flags & VAR_ARRAY) {
DeleteArray(iPtr, Tcl_GetHashKey(tablePtr, hPtr), varPtr, flags);
}
if (varPtr->valueSpace > 0) {
/*
* SPECIAL TRICK: it's possible that the interpreter's result
* currently points to this variable (for example, a "set" or
* "lappend" command was the last command in a procedure that's
* being returned from). If this is the case, then just pass
* ownership of the value string to the Tcl interpreter.
*/
if (iPtr->result == varPtr->value.string) {
iPtr->freeProc = TCL_DYNAMIC;
} else {
ckfree(varPtr->value.string);
}
varPtr->valueSpace = 0;
}
varPtr->hPtr = NULL;
varPtr->tracePtr = NULL;
varPtr->flags = VAR_UNDEFINED;
/*
* Recycle the variable's memory space if there aren't any upvar's
* pointing to it. If there are upvars, then the variable will
* get freed when the last upvar goes away.
*/
if (varPtr->refCount == 0) {
ckfree((char *) varPtr);
}
}
Tcl_DeleteHashTable(tablePtr);
}
/*
*----------------------------------------------------------------------
*
* DeleteArray --
*
* This procedure is called to free up everything in an array
* variable. It's the caller's responsibility to make sure
* that the array is no longer accessible before this procedure
* is called.
*
* Results:
* None.
*
* Side effects:
* All storage associated with varPtr's array elements is deleted
* (including the hash table). Delete trace procedures for
* array elements are invoked.
*
*----------------------------------------------------------------------
*/
static void
DeleteArray(iPtr, arrayName, varPtr, flags)
Interp *iPtr; /* Interpreter containing array. */
char *arrayName; /* Name of array (used for trace
* callbacks). */
Var *varPtr; /* Pointer to variable structure. */
int flags; /* Flags to pass to CallTraces:
* TCL_TRACE_UNSETS and sometimes
* TCL_INTERP_DESTROYED and/or
* TCL_GLOBAL_ONLY. */
{
Tcl_HashSearch search;
register Tcl_HashEntry *hPtr;
register Var *elPtr;
ActiveVarTrace *activePtr;
DeleteSearches(varPtr);
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
elPtr = (Var *) Tcl_GetHashValue(hPtr);
if (elPtr->valueSpace != 0) {
/*
* SPECIAL TRICK: it's possible that the interpreter's result
* currently points to this element (for example, a "set" or
* "lappend" command was the last command in a procedure that's
* being returned from). If this is the case, then just pass
* ownership of the value string to the Tcl interpreter.
*/
if (iPtr->result == elPtr->value.string) {
iPtr->freeProc = TCL_DYNAMIC;
} else {
ckfree(elPtr->value.string);
}
elPtr->valueSpace = 0;
}
elPtr->hPtr = NULL;
if (elPtr->tracePtr != NULL) {
elPtr->flags &= ~VAR_TRACE_ACTIVE;
(void) CallTraces(iPtr, (Var *) NULL, elPtr, arrayName,
Tcl_GetHashKey(varPtr->value.tablePtr, hPtr), flags);
while (elPtr->tracePtr != NULL) {
VarTrace *tracePtr = elPtr->tracePtr;
elPtr->tracePtr = tracePtr->nextPtr;
ckfree((char *) tracePtr);
}
for (activePtr = iPtr->activeTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == elPtr) {
activePtr->nextTracePtr = NULL;
}
}
}
elPtr->flags = VAR_UNDEFINED;
if (elPtr->refCount == 0) {
ckfree((char *) elPtr);
}
}
Tcl_DeleteHashTable(varPtr->value.tablePtr);
ckfree((char *) varPtr->value.tablePtr);
}
/*
*----------------------------------------------------------------------
*
* CleanupVar --
*
* This procedure is called when it looks like it may be OK
* to free up the variable's record and hash table entry, and
* those of its containing parent. It's called, for example,
* when a trace on a variable deletes the variable.
*
* Results:
* None.
*
* Side effects:
* If the variable (or its containing array) really is dead then
* its record, and possibly its hash table entry, gets freed up.
*
*----------------------------------------------------------------------
*/
static void
CleanupVar(varPtr, arrayPtr)
Var *varPtr; /* Pointer to variable that may be a
* candidate for being expunged. */
Var *arrayPtr; /* Array that contains the variable, or
* NULL if this variable isn't an array
* element. */
{
if ((varPtr->flags & VAR_UNDEFINED) && (varPtr->refCount == 0)
&& (varPtr->tracePtr == NULL)) {
if (varPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(varPtr->hPtr);
}
ckfree((char *) varPtr);
}
if (arrayPtr != NULL) {
if ((arrayPtr->flags & VAR_UNDEFINED) && (arrayPtr->refCount == 0)
&& (arrayPtr->tracePtr == NULL)) {
if (arrayPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(arrayPtr->hPtr);
}
ckfree((char *) arrayPtr);
}
}
return;
}
/*
*----------------------------------------------------------------------
*
* VarErrMsg --
*
* Generate a reasonable error message describing why a variable
* operation failed.
*
* Results:
* None.
*
* Side effects:
* Interp->result is reset to hold a message identifying the
* variable given by part1 and part2 and describing why the
* variable operation failed.
*
*----------------------------------------------------------------------
*/
static void
VarErrMsg(interp, part1, part2, operation, reason)
Tcl_Interp *interp; /* Interpreter in which to record message. */
char *part1, *part2; /* Variable's two-part name. */
char *operation; /* String describing operation that failed,
* e.g. "read", "set", or "unset". */
char *reason; /* String describing why operation failed. */
{
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "can't ", operation, " \"", part1, (char *) NULL);
if (part2 != NULL) {
Tcl_AppendResult(interp, "(", part2, ")", (char *) NULL);
}
Tcl_AppendResult(interp, "\": ", reason, (char *) NULL);
}
Reference in New Issue View Git Blame Copy Permalink