通讯编程

开发平台：

Visual C++

tclVar.c：源码内容

/* Initialized to avoid compiler
* warning. */
int i;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "varName ?value value ...?");
return TCL_ERROR;
}
if (objc == 2) {
varValuePtr = Tcl_ObjGetVar2(interp, objv[1], NULL, TCL_LEAVE_ERR_MSG);
if (varValuePtr == NULL) {
return TCL_ERROR;
}
} else {
varPtr = TclObjLookupVar(interp, objv[1], NULL, TCL_LEAVE_ERR_MSG,
"set", /*createPart1*/ 1, /*createPart2*/ 1, &arrayPtr);
part1 = TclGetString(objv[1]);
if (varPtr == NULL) {
return TCL_ERROR;
}
for (i = 2; i < objc; i++) {
/*
* Note that we do not need to increase the refCount of
* the Var pointers: should a trace delete the variable,
* the return value of TclPtrSetVar will be NULL, and we
* will not access the variable again.
*/
varValuePtr = TclPtrSetVar(interp, varPtr, arrayPtr, part1, NULL,
objv[i], (TCL_APPEND_VALUE | TCL_LEAVE_ERR_MSG));
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
}
Tcl_SetObjResult(interp, varValuePtr);
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_LappendObjCmd --
*
* This object-based procedure is invoked to process the "lappend"
* Tcl command. See the user documentation for details on what it does.
*
* Results:
* A standard Tcl object result value.
*
* Side effects:
* A variable's value may be changed.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_LappendObjCmd(dummy, interp, objc, objv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
Tcl_Obj *varValuePtr, *newValuePtr;
register List *listRepPtr;
register Tcl_Obj **elemPtrs;
int numElems, numRequired, createdNewObj, i, j;
Var *varPtr, *arrayPtr;
char *part1;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "varName ?value value ...?");
return TCL_ERROR;
}
if (objc == 2) {
newValuePtr = Tcl_ObjGetVar2(interp, objv[1], (Tcl_Obj *) NULL, 0);
if (newValuePtr == NULL) {
/*
* The variable doesn't exist yet. Just create it with an empty
* initial value.
*/
varValuePtr = Tcl_NewObj();
Tcl_IncrRefCount(varValuePtr);
newValuePtr = Tcl_ObjSetVar2(interp, objv[1], NULL, varValuePtr,
TCL_LEAVE_ERR_MSG);
Tcl_DecrRefCount(varValuePtr);
if (newValuePtr == NULL) {
return TCL_ERROR;
}
} else {
int result;
result = Tcl_ListObjLength(interp, newValuePtr, &numElems);
if (result != TCL_OK) {
return result;
}
}
} else {
/*
* We have arguments to append. We used to call Tcl_SetVar2 to
* append each argument one at a time to ensure that traces were run
* for each append step. We now append the arguments all at once
* because it's faster. Note that a read trace and a write trace for
* the variable will now each only be called once. Also, if the
* variable's old value is unshared we modify it directly, otherwise
* we create a new copy to modify: this is "copy on write".
*
* Note that you have to protect the variable pointers around
* the TclPtrGetVar call to insure that they remain valid
* even if the variable was undefined and unused.
*/
varPtr = TclObjLookupVar(interp, objv[1], NULL, TCL_LEAVE_ERR_MSG,
"set", /*createPart1*/ 1, /*createPart2*/ 1, &arrayPtr);
if (varPtr == NULL) {
return TCL_ERROR;
}
varPtr->refCount++;
if (arrayPtr != NULL) {
arrayPtr->refCount++;
}
part1 = TclGetString(objv[1]);
varValuePtr = TclPtrGetVar(interp, varPtr, arrayPtr, part1, NULL,
TCL_LEAVE_ERR_MSG);
varPtr->refCount--;
if (arrayPtr != NULL) {
arrayPtr->refCount--;
}
createdNewObj = 0;
if (varValuePtr == NULL) {
/*
* We couldn't read the old value: either the var doesn't yet
* exist or it's an array element. If it's new, we will try to
* create it with Tcl_ObjSetVar2 below.
*/
varValuePtr = Tcl_NewObj();
createdNewObj = 1;
} else if (Tcl_IsShared(varValuePtr)) {
varValuePtr = Tcl_DuplicateObj(varValuePtr);
createdNewObj = 1;
}
/*
* Convert the variable's old value to a list object if necessary.
*/
if (varValuePtr->typePtr != &tclListType) {
int result = tclListType.setFromAnyProc(interp, varValuePtr);
if (result != TCL_OK) {
if (createdNewObj) {
Tcl_DecrRefCount(varValuePtr); /* free unneeded obj. */
}
return result;
}
}
listRepPtr = (List *) varValuePtr->internalRep.twoPtrValue.ptr1;
elemPtrs = listRepPtr->elements;
numElems = listRepPtr->elemCount;
/*
* If there is no room in the current array of element pointers,
* allocate a new, larger array and copy the pointers to it.
*/
numRequired = numElems + (objc-2);
if (numRequired > listRepPtr->maxElemCount) {
int newMax = (2 * numRequired);
Tcl_Obj **newElemPtrs = (Tcl_Obj **)
ckalloc((unsigned) (newMax * sizeof(Tcl_Obj *)));
memcpy((VOID *) newElemPtrs, (VOID *) elemPtrs,
(size_t) (numElems * sizeof(Tcl_Obj *)));
listRepPtr->maxElemCount = newMax;
listRepPtr->elements = newElemPtrs;
ckfree((char *) elemPtrs);
elemPtrs = newElemPtrs;
}
/*
* Insert the new elements at the end of the list.
*/
for (i = 2, j = numElems; i < objc; i++, j++) {
elemPtrs[j] = objv[i];
Tcl_IncrRefCount(objv[i]);
}
listRepPtr->elemCount = numRequired;
/*
* Invalidate and free any old string representation since it no
* longer reflects the list's internal representation.
*/
Tcl_InvalidateStringRep(varValuePtr);
/*
* Now store the list object back into the variable. If there is an
* error setting the new value, decrement its ref count if it
* was new and we didn't create the variable.
*/
Tcl_IncrRefCount(varValuePtr);
newValuePtr = TclPtrSetVar(interp, varPtr, arrayPtr, part1, NULL,
varValuePtr, TCL_LEAVE_ERR_MSG);
Tcl_DecrRefCount(varValuePtr);
if (newValuePtr == NULL) {
return TCL_ERROR;
}
}
/*
* Set the interpreter's object result to refer to the variable's value
* object.
*/
Tcl_SetObjResult(interp, newValuePtr);
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_ArrayObjCmd --
*
* This object-based procedure is invoked to process the "array" Tcl
* command. See the user documentation for details on what it does.
*
* Results:
* A standard Tcl result object.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_ArrayObjCmd(dummy, interp, objc, objv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
/*
* The list of constants below should match the arrayOptions string array
* below.
*/
enum {ARRAY_ANYMORE, ARRAY_DONESEARCH, ARRAY_EXISTS, ARRAY_GET,
ARRAY_NAMES, ARRAY_NEXTELEMENT, ARRAY_SET, ARRAY_SIZE,
ARRAY_STARTSEARCH, ARRAY_STATISTICS, ARRAY_UNSET};
static CONST char *arrayOptions[] = {
"anymore", "donesearch", "exists", "get", "names", "nextelement",
"set", "size", "startsearch", "statistics", "unset", (char *) NULL
};
Interp *iPtr = (Interp *) interp;
Var *varPtr, *arrayPtr;
Tcl_HashEntry *hPtr;
Tcl_Obj *resultPtr, *varNamePtr;
int notArray;
char *varName;
int index, result;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 1, objv, "option arrayName ?arg ...?");
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objv[1], arrayOptions, "option",
0, &index) != TCL_OK) {
return TCL_ERROR;
}
/*
* Locate the array variable
*/
varNamePtr = objv[2];
varName = TclGetString(varNamePtr);
varPtr = TclObjLookupVar(interp, varNamePtr, NULL, /*flags*/ 0,
/*msg*/ 0, /*createPart1*/ 0, /*createPart2*/ 0, &arrayPtr);
/*
* Special array trace used to keep the env array in sync for
* array names, array get, etc.
*/
if (varPtr != NULL && varPtr->tracePtr != NULL
&& (TclIsVarArray(varPtr) || TclIsVarUndefined(varPtr))) {
if (TCL_ERROR == CallVarTraces(iPtr, arrayPtr, varPtr, varName, NULL,
(TCL_LEAVE_ERR_MSG|TCL_NAMESPACE_ONLY|TCL_GLOBAL_ONLY|
TCL_TRACE_ARRAY), /* leaveErrMsg */ 1)) {
return TCL_ERROR;
}
}
/*
* Verify that it is indeed an array variable. This test comes after
* the traces - the variable may actually become an array as an effect
* of said traces.
*/
notArray = 0;
if ((varPtr == NULL) || !TclIsVarArray(varPtr)
|| TclIsVarUndefined(varPtr)) {
notArray = 1;
}
/*
* We have to wait to get the resultPtr until here because
* CallVarTraces can affect the result.
*/
resultPtr = Tcl_GetObjResult(interp);
switch (index) {
case ARRAY_ANYMORE: {
ArraySearch *searchPtr;
if (objc != 4) {
Tcl_WrongNumArgs(interp, 2, objv,
"arrayName searchId");
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, varName, objv[3]);
if (searchPtr == NULL) {
return TCL_ERROR;
}
while (1) {
Var *varPtr2;
if (searchPtr->nextEntry != NULL) {
varPtr2 = (Var *) Tcl_GetHashValue(searchPtr->nextEntry);
if (!TclIsVarUndefined(varPtr2)) {
break;
}
}
searchPtr->nextEntry = Tcl_NextHashEntry(&searchPtr->search);
if (searchPtr->nextEntry == NULL) {
Tcl_SetIntObj(resultPtr, 0);
return TCL_OK;
}
}
Tcl_SetIntObj(resultPtr, 1);
break;
}
case ARRAY_DONESEARCH: {
ArraySearch *searchPtr, *prevPtr;
if (objc != 4) {
Tcl_WrongNumArgs(interp, 2, objv,
"arrayName searchId");
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, varName, objv[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);
break;
}
case ARRAY_EXISTS: {
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName");
return TCL_ERROR;
}
Tcl_SetIntObj(resultPtr, !notArray);
break;
}
case ARRAY_GET: {
Tcl_HashSearch search;
Var *varPtr2;
char *pattern = NULL;
char *name;
Tcl_Obj *namePtr, *valuePtr, *nameLstPtr, *tmpResPtr, **namePtrPtr;
int i, count;
if ((objc != 3) && (objc != 4)) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName ?pattern?");
return TCL_ERROR;
}
if (notArray) {
return TCL_OK;
}
if (objc == 4) {
pattern = TclGetString(objv[3]);
}
/*
* Store the array names in a new object.
*/
nameLstPtr = Tcl_NewObj();
Tcl_IncrRefCount(nameLstPtr);
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (TclIsVarUndefined(varPtr2)) {
continue;
}
name = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
if ((objc == 4) && !Tcl_StringMatch(name, pattern)) {
continue; /* element name doesn't match pattern */
}
namePtr = Tcl_NewStringObj(name, -1);
result = Tcl_ListObjAppendElement(interp, nameLstPtr,
namePtr);
if (result != TCL_OK) {
Tcl_DecrRefCount(namePtr); /* free unneeded name obj */
Tcl_DecrRefCount(nameLstPtr);
return result;
}
}
/*
* Make sure the Var structure of the array is not removed by
* a trace while we're working.
*/
varPtr->refCount++;
/*
* Get the array values corresponding to each element name
*/
tmpResPtr = Tcl_NewObj();
result = Tcl_ListObjGetElements(interp, nameLstPtr,
&count, &namePtrPtr);
if (result != TCL_OK) {
goto errorInArrayGet;
}
for (i = 0; i < count; i++) {
namePtr = *namePtrPtr++;
valuePtr = Tcl_ObjGetVar2(interp, objv[2], namePtr,
TCL_LEAVE_ERR_MSG);
if (valuePtr == NULL) {
/*
* Some trace played a trick on us; we need to diagnose to
* adapt our behaviour: was the array element unset, or did
* the modification modify the complete array?
*/
if (TclIsVarArray(varPtr) && !TclIsVarUndefined(varPtr)) {
/*
* The array itself looks OK, the variable was
* undefined: forget it.
*/
continue;
} else {
result = TCL_ERROR;
goto errorInArrayGet;
}
}
result = Tcl_ListObjAppendElement(interp, tmpResPtr, namePtr);
if (result != TCL_OK) {
goto errorInArrayGet;
}
result = Tcl_ListObjAppendElement(interp, tmpResPtr, valuePtr);
if (result != TCL_OK) {
goto errorInArrayGet;
}
}
varPtr->refCount--;
Tcl_SetObjResult(interp, tmpResPtr);
Tcl_DecrRefCount(nameLstPtr);
break;
errorInArrayGet:
varPtr->refCount--;
Tcl_DecrRefCount(nameLstPtr);
Tcl_DecrRefCount(tmpResPtr); /* free unneeded temp result obj */
return result;
}
case ARRAY_NAMES: {
Tcl_HashSearch search;
Var *varPtr2;
char *pattern = NULL;
char *name;
Tcl_Obj *namePtr;
int mode, matched = 0;
static CONST char *options[] = {
"-exact", "-glob", "-regexp", (char *) NULL
};
enum options { OPT_EXACT, OPT_GLOB, OPT_REGEXP };
mode = OPT_GLOB;
if ((objc < 3) || (objc > 5)) {
Tcl_WrongNumArgs(interp, 2, objv,
"arrayName ?mode? ?pattern?");
return TCL_ERROR;
}
if (notArray) {
return TCL_OK;
}
if (objc == 4) {
pattern = Tcl_GetString(objv[3]);
} else if (objc == 5) {
pattern = Tcl_GetString(objv[4]);
if (Tcl_GetIndexFromObj(interp, objv[3], options, "option",
0, &mode) != TCL_OK) {
return TCL_ERROR;
}
}
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (TclIsVarUndefined(varPtr2)) {
continue;
}
name = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
if (objc > 3) {
switch ((enum options) mode) {
case OPT_EXACT:
matched = (strcmp(name, pattern) == 0);
break;
case OPT_GLOB:
matched = Tcl_StringMatch(name, pattern);
break;
case OPT_REGEXP:
matched = Tcl_RegExpMatch(interp, name,
pattern);
if (matched < 0) {
return TCL_ERROR;
}
break;
}
if (matched == 0) {
continue;
}
}
namePtr = Tcl_NewStringObj(name, -1);
result = Tcl_ListObjAppendElement(interp, resultPtr, namePtr);
if (result != TCL_OK) {
Tcl_DecrRefCount(namePtr); /* free unneeded name obj */
return result;
}
}
break;
}
case ARRAY_NEXTELEMENT: {
ArraySearch *searchPtr;
Tcl_HashEntry *hPtr;
if (objc != 4) {
Tcl_WrongNumArgs(interp, 2, objv,
"arrayName searchId");
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = ParseSearchId(interp, varPtr, varName, objv[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 (!TclIsVarUndefined(varPtr2)) {
break;
}
}
Tcl_SetStringObj(resultPtr,
Tcl_GetHashKey(varPtr->value.tablePtr, hPtr), -1);
break;
}
case ARRAY_SET: {
if (objc != 4) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName list");
return TCL_ERROR;
}
return(TclArraySet(interp, objv[2], objv[3]));
}
case ARRAY_SIZE: {
Tcl_HashSearch search;
Var *varPtr2;
int size;
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName");
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 (TclIsVarUndefined(varPtr2)) {
continue;
}
size++;
}
}
Tcl_SetIntObj(resultPtr, size);
break;
}
case ARRAY_STARTSEARCH: {
ArraySearch *searchPtr;
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName");
return TCL_ERROR;
}
if (notArray) {
goto error;
}
searchPtr = (ArraySearch *) ckalloc(sizeof(ArraySearch));
if (varPtr->searchPtr == NULL) {
searchPtr->id = 1;
Tcl_AppendStringsToObj(resultPtr, "s-1-", varName,
(char *) NULL);
} else {
char string[TCL_INTEGER_SPACE];
searchPtr->id = varPtr->searchPtr->id + 1;
TclFormatInt(string, searchPtr->id);
Tcl_AppendStringsToObj(resultPtr, "s-", string, "-", varName,
(char *) NULL);
}
searchPtr->varPtr = varPtr;
searchPtr->nextEntry = Tcl_FirstHashEntry(varPtr->value.tablePtr,
&searchPtr->search);
searchPtr->nextPtr = varPtr->searchPtr;
varPtr->searchPtr = searchPtr;
break;
}
case ARRAY_STATISTICS: {
CONST char *stats;
if (notArray) {
goto error;
}
stats = Tcl_HashStats(varPtr->value.tablePtr);
if (stats != NULL) {
Tcl_SetStringObj(Tcl_GetObjResult(interp), stats, -1);
ckfree((void *)stats);
} else {
Tcl_SetResult(interp, "error reading array statistics",
TCL_STATIC);
return TCL_ERROR;
}
break;
}
case ARRAY_UNSET: {
Tcl_HashSearch search;
Var *varPtr2;
char *pattern = NULL;
char *name;
if ((objc != 3) && (objc != 4)) {
Tcl_WrongNumArgs(interp, 2, objv, "arrayName ?pattern?");
return TCL_ERROR;
}
if (notArray) {
return TCL_OK;
}
if (objc == 3) {
/*
* When no pattern is given, just unset the whole array
*/
if (TclObjUnsetVar2(interp, varNamePtr, NULL, 0)
!= TCL_OK) {
return TCL_ERROR;
}
} else {
pattern = Tcl_GetString(objv[3]);
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr,
&search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
varPtr2 = (Var *) Tcl_GetHashValue(hPtr);
if (TclIsVarUndefined(varPtr2)) {
continue;
}
name = Tcl_GetHashKey(varPtr->value.tablePtr, hPtr);
if (Tcl_StringMatch(name, pattern) &&
(TclObjUnsetVar2(interp, varNamePtr, name, 0)
!= TCL_OK)) {
return TCL_ERROR;
}
}
}
break;
}
}
return TCL_OK;
error:
Tcl_AppendStringsToObj(resultPtr, """, varName, "" isn't an array",
(char *) NULL);
return TCL_ERROR;
}
/*
*----------------------------------------------------------------------
*
* TclArraySet --
*
* Set the elements of an array. If there are no elements to
* set, create an empty array. This routine is used by the
* Tcl_ArrayObjCmd and by the TclSetupEnv routine.
*
* Results:
* A standard Tcl result object.
*
* Side effects:
* A variable will be created if one does not already exist.
*
*----------------------------------------------------------------------
*/
int
TclArraySet(interp, arrayNameObj, arrayElemObj)
Tcl_Interp *interp; /* Current interpreter. */
Tcl_Obj *arrayNameObj; /* The array name. */
Tcl_Obj *arrayElemObj; /* The array elements list. If this is
* NULL, create an empty array. */
{
Var *varPtr, *arrayPtr;
Tcl_Obj **elemPtrs;
int result, elemLen, i, nameLen;
char *varName, *p;
varName = Tcl_GetStringFromObj(arrayNameObj, &nameLen);
p = varName + nameLen - 1;
if (*p == ')') {
while (--p >= varName) {
if (*p == '(') {
VarErrMsg(interp, varName, NULL, "set", needArray);
return TCL_ERROR;
}
}
}
varPtr = TclObjLookupVar(interp, arrayNameObj, NULL,
/*flags*/ TCL_LEAVE_ERR_MSG, /*msg*/ "set", /*createPart1*/ 1,
/*createPart2*/ 0, &arrayPtr);
if (varPtr == NULL) {
return TCL_ERROR;
}
if (arrayElemObj != NULL) {
result = Tcl_ListObjGetElements(interp, arrayElemObj,
&elemLen, &elemPtrs);
if (result != TCL_OK) {
return result;
}
if (elemLen & 1) {
Tcl_ResetResult(interp);
Tcl_AppendToObj(Tcl_GetObjResult(interp),
"list must have an even number of elements", -1);
return TCL_ERROR;
}
if (elemLen > 0) {
/*
* We needn't worry about traces invalidating arrayPtr:
* should that be the case, TclPtrSetVar will return NULL
* so that we break out of the loop and return an error.
*/
for (i = 0; i < elemLen; i += 2) {
char *part2 = TclGetString(elemPtrs[i]);
Var *elemVarPtr = TclLookupArrayElement(interp, varName,
part2, TCL_LEAVE_ERR_MSG, "set", 1, 1, varPtr);
if ((elemVarPtr == NULL) ||
(TclPtrSetVar(interp, elemVarPtr, varPtr, varName,
part2, elemPtrs[i+1], TCL_LEAVE_ERR_MSG) == NULL)) {
result = TCL_ERROR;
break;
}
/*
* The TclPtrSetVar call might have shimmered
* arrayElemObj to another type, so re-fetch
* the pointers for safety.
*/
Tcl_ListObjGetElements(NULL, arrayElemObj,
&elemLen, &elemPtrs);
}
return result;
}
}
/*
* The list is empty make sure we have an array, or create
* one if necessary.
*/
if (varPtr != NULL) {
if (!TclIsVarUndefined(varPtr) && TclIsVarArray(varPtr)) {
/*
* Already an array, done.
*/
return TCL_OK;
}
if (TclIsVarArrayElement(varPtr) || !TclIsVarUndefined(varPtr)) {
/*
* Either an array element, or a scalar: lose!
*/
VarErrMsg(interp, varName, (char *)NULL, "array set", needArray);
return TCL_ERROR;
}
}
TclSetVarArray(varPtr);
TclClearVarUndefined(varPtr);
varPtr->value.tablePtr =
(Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(varPtr->value.tablePtr, TCL_STRING_KEYS);
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* ObjMakeUpvar --
*
* 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
ObjMakeUpvar(interp, framePtr, otherP1Ptr, otherP2, otherFlags, myName, myFlags, index)
Tcl_Interp *interp; /* Interpreter containing variables. Used
* for error messages, too. */
CallFrame *framePtr; /* Call frame containing "other" variable.
* NULL means use global :: context. */
Tcl_Obj *otherP1Ptr;
CONST char *otherP2; /* Two-part name of variable in framePtr. */
CONST int otherFlags; /* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
* indicates scope of "other" variable. */
CONST char *myName; /* Name of variable which will refer to
* otherP1/otherP2. Must be a scalar. */
int myFlags; /* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
* indicates scope of myName. */
int index; /* If the variable to be linked is an indexed
* scalar, this is its index. Otherwise, -1. */
{
Interp *iPtr = (Interp *) interp;
Var *otherPtr, *varPtr, *arrayPtr;
CallFrame *varFramePtr;
CONST char *errMsg;
/*
* Find "other" in "framePtr". If not looking up other in just the
* current namespace, temporarily replace the current var frame
* pointer in the interpreter in order to use TclObjLookupVar.
*/
varFramePtr = iPtr->varFramePtr;
if (!(otherFlags & TCL_NAMESPACE_ONLY)) {
iPtr->varFramePtr = framePtr;
}
otherPtr = TclObjLookupVar(interp, otherP1Ptr, otherP2,
(otherFlags | TCL_LEAVE_ERR_MSG), "access",
/*createPart1*/ 1, /*createPart2*/ 1, &arrayPtr);
if (!(otherFlags & TCL_NAMESPACE_ONLY)) {
iPtr->varFramePtr = varFramePtr;
}
if (otherPtr == NULL) {
return TCL_ERROR;
}
if (index >= 0) {
if (!varFramePtr->isProcCallFrame) {
panic("ObjMakeUpvar called with an index outside from a proc.n");
}
varPtr = &(varFramePtr->compiledLocals[index]);
} else {
/*
* Check that we are not trying to create a namespace var linked to
* a local variable in a procedure. If we allowed this, the local
* variable in the shorter-lived procedure frame could go away
* leaving the namespace var's reference invalid.
*/
if (((otherP2 ? arrayPtr->nsPtr : otherPtr->nsPtr) == NULL)
&& ((myFlags & (TCL_GLOBAL_ONLY | TCL_NAMESPACE_ONLY))
|| (varFramePtr == NULL)
|| !varFramePtr->isProcCallFrame
|| (strstr(myName, "::") != NULL))) {
Tcl_AppendResult((Tcl_Interp *) iPtr, "bad variable name "",
myName, "": upvar won't create namespace variable that ",
"refers to procedure variable", (char *) NULL);
return TCL_ERROR;
}
/*
* Lookup and eventually create the new variable. Set the flag bit
* LOOKUP_FOR_UPVAR to indicate the special resolution rules for
* upvar purposes:
* - Bug #696893 - variable is either proc-local or in the current
* namespace; never follow the second (global) resolution path
* - Bug #631741 - do not use special namespace or interp resolvers
*/
varPtr = TclLookupSimpleVar(interp, myName, (myFlags | LOOKUP_FOR_UPVAR),
/* create */ 1, &errMsg, &index);
if (varPtr == NULL) {
VarErrMsg(interp, myName, NULL, "create", errMsg);
return TCL_ERROR;
}
}
if (varPtr == otherPtr) {
Tcl_SetResult((Tcl_Interp *) iPtr,
"can't upvar from variable to itself", TCL_STATIC);
return TCL_ERROR;
}
if (varPtr->tracePtr != NULL) {
Tcl_AppendResult((Tcl_Interp *) iPtr, "variable "", myName,
"" has traces: can't use for upvar", (char *) NULL);
return TCL_ERROR;
} else if (!TclIsVarUndefined(varPtr)) {
/*
* The variable already existed. Make sure this variable "varPtr"
* isn't the same as "otherPtr" (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.
*/
if (TclIsVarLink(varPtr)) {
Var *linkPtr = varPtr->value.linkPtr;
if (linkPtr == otherPtr) {
return TCL_OK;
}
linkPtr->refCount--;
if (TclIsVarUndefined(linkPtr)) {
CleanupVar(linkPtr, (Var *) NULL);
}
} else {
Tcl_AppendResult((Tcl_Interp *) iPtr, "variable "", myName,
"" already exists", (char *) NULL);
return TCL_ERROR;
}
}
TclSetVarLink(varPtr);
TclClearVarUndefined(varPtr);
varPtr->value.linkPtr = 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 the interp's 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. */
CONST char *frameName; /* Name of the frame containing the source
* variable, such as "1" or "#0". */
CONST char *varName; /* Name of a variable in interp to link to.
* May be either a scalar name or an
* element in an array. */
CONST char *localName; /* Name of link variable. */
int flags; /* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
* indicates scope of localName. */
{
return Tcl_UpVar2(interp, frameName, varName, 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 the interp's 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. */
CONST char *frameName; /* Name of the frame containing the source
* variable, such as "1" or "#0". */
CONST char *part1;
CONST char *part2; /* Two parts of source variable name to
* link to. */
CONST char *localName; /* Name of link variable. */
int flags; /* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
* indicates scope of localName. */
{
int result;
CallFrame *framePtr;
Tcl_Obj *part1Ptr;
if (TclGetFrame(interp, frameName, &framePtr) == -1) {
return TCL_ERROR;
}
part1Ptr = Tcl_NewStringObj(part1, -1);
Tcl_IncrRefCount(part1Ptr);
result = ObjMakeUpvar(interp, framePtr, part1Ptr, part2, 0,
localName, flags, -1);
TclDecrRefCount(part1Ptr);
return result;
}
/*
*----------------------------------------------------------------------
*
* Tcl_GetVariableFullName --
*
* Given a Tcl_Var token returned by Tcl_FindNamespaceVar, this
* procedure appends to an object the namespace variable's full
* name, qualified by a sequence of parent namespace names.
*
* Results:
* None.
*
* Side effects:
* The variable's fully-qualified name is appended to the string
* representation of objPtr.
*
*----------------------------------------------------------------------
*/
void
Tcl_GetVariableFullName(interp, variable, objPtr)
Tcl_Interp *interp; /* Interpreter containing the variable. */
Tcl_Var variable; /* Token for the variable returned by a
* previous call to Tcl_FindNamespaceVar. */
Tcl_Obj *objPtr; /* Points to the object onto which the
* variable's full name is appended. */
{
Interp *iPtr = (Interp *) interp;
register Var *varPtr = (Var *) variable;
char *name;
/*
* Add the full name of the containing namespace (if any), followed by
* the "::" separator, then the variable name.
*/
if (varPtr != NULL) {
if (!TclIsVarArrayElement(varPtr)) {
if (varPtr->nsPtr != NULL) {
Tcl_AppendToObj(objPtr, varPtr->nsPtr->fullName, -1);
if (varPtr->nsPtr != iPtr->globalNsPtr) {
Tcl_AppendToObj(objPtr, "::", 2);
}
}
if (varPtr->name != NULL) {
Tcl_AppendToObj(objPtr, varPtr->name, -1);
} else if (varPtr->hPtr != NULL) {
name = Tcl_GetHashKey(varPtr->hPtr->tablePtr, varPtr->hPtr);
Tcl_AppendToObj(objPtr, name, -1);
}
}
}
}
/*
*----------------------------------------------------------------------
*
* Tcl_GlobalObjCmd --
*
* This object-based procedure is invoked to process the "global" Tcl
* command. See the user documentation for details on what it does.
*
* Results:
* A standard Tcl object result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
int
Tcl_GlobalObjCmd(dummy, interp, objc, objv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
Interp *iPtr = (Interp *) interp;
register Tcl_Obj *objPtr;
char *varName;
register char *tail;
int result, i;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "varName ?varName ...?");
return TCL_ERROR;
}
/*
* If we are not executing inside a Tcl procedure, just return.
*/
if ((iPtr->varFramePtr == NULL)
|| !iPtr->varFramePtr->isProcCallFrame) {
return TCL_OK;
}
for (i = 1; i < objc; i++) {
/*
* Make a local variable linked to its counterpart in the global ::
* namespace.
*/
objPtr = objv[i];
varName = TclGetString(objPtr);
/*
* The variable name might have a scope qualifier, but the name for
* the local "link" variable must be the simple name at the tail.
*/
for (tail = varName; *tail != ''; tail++) {
/* empty body */
}
while ((tail > varName) && ((*tail != ':') || (*(tail-1) != ':'))) {
tail--;
}
if ((*tail == ':') && (tail > varName)) {
tail++;
}
/*
* Link to the variable "varName" in the global :: namespace.
*/
result = ObjMakeUpvar(interp, (CallFrame *) NULL,
objPtr, NULL, /*otherFlags*/ TCL_GLOBAL_ONLY,
/*myName*/ tail, /*myFlags*/ 0, -1);
if (result != TCL_OK) {
return result;
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_VariableObjCmd --
*
* Invoked to implement the "variable" command that creates one or more
* global variables. Handles the following syntax:
*
* variable ?name value...? name ?value?
*
* One or more variables can be created. The variables are initialized
* with the specified values. The value for the last variable is
* optional.
*
* If the variable does not exist, it is created and given the optional
* value. If it already exists, it is simply set to the optional
* value. Normally, "name" is an unqualified name, so it is created in
* the current namespace. If it includes namespace qualifiers, it can
* be created in another namespace.
*
* If the variable command is executed inside a Tcl procedure, it
* creates a local variable linked to the newly-created namespace
* variable.
*
* Results:
* Returns TCL_OK if the variable is found or created. Returns
* TCL_ERROR if anything goes wrong.
*
* Side effects:
* If anything goes wrong, this procedure returns an error message
* as the result in the interpreter's result object.
*
*----------------------------------------------------------------------
*/
int
Tcl_VariableObjCmd(dummy, interp, objc, objv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
Interp *iPtr = (Interp *) interp;
char *varName, *tail, *cp;
Var *varPtr, *arrayPtr;
Tcl_Obj *varValuePtr;
int i, result;
Tcl_Obj *varNamePtr;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "?name value...? name ?value?");
return TCL_ERROR;
}
for (i = 1; i < objc; i = i+2) {
/*
* Look up each variable in the current namespace context, creating
* it if necessary.
*/
varNamePtr = objv[i];
varName = TclGetString(varNamePtr);
varPtr = TclObjLookupVar(interp, varNamePtr, NULL,
(TCL_NAMESPACE_ONLY | TCL_LEAVE_ERR_MSG), "define",
/*createPart1*/ 1, /*createPart2*/ 0, &arrayPtr);
if (arrayPtr != NULL) {
/*
* Variable cannot be an element in an array. If arrayPtr is
* non-null, it is, so throw up an error and return.
*/
VarErrMsg(interp, varName, NULL, "define", isArrayElement);
return TCL_ERROR;
}
if (varPtr == NULL) {
return TCL_ERROR;
}
/*
* Mark the variable as a namespace variable and increment its
* reference count so that it will persist until its namespace is
* destroyed or until the variable is unset.
*/
if (!(varPtr->flags & VAR_NAMESPACE_VAR)) {
varPtr->flags |= VAR_NAMESPACE_VAR;
varPtr->refCount++;
}
/*
* If a value was specified, set the variable to that value.
* Otherwise, if the variable is new, leave it undefined.
* (If the variable already exists and no value was specified,
* leave its value unchanged; just create the local link if
* we're in a Tcl procedure).
*/
if (i+1 < objc) { /* a value was specified */
varValuePtr = TclPtrSetVar(interp, varPtr, arrayPtr, varName, NULL,
objv[i+1], (TCL_NAMESPACE_ONLY | TCL_LEAVE_ERR_MSG));
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
/*
* If we are executing inside a Tcl procedure, create a local
* variable linked to the new namespace variable "varName".
*/
if ((iPtr->varFramePtr != NULL)
&& iPtr->varFramePtr->isProcCallFrame) {
/*
* varName might have a scope qualifier, but the name for the
* local "link" variable must be the simple name at the tail.
*
* Locate tail in one pass: drop any prefix after two *or more*
* consecutive ":" characters).
*/
for (tail = cp = varName; *cp != ''; ) {
if (*cp++ == ':') {
while (*cp == ':') {
tail = ++cp;
}
}
}
/*
* Create a local link "tail" to the variable "varName" in the
* current namespace.
*/
result = ObjMakeUpvar(interp, (CallFrame *) NULL,
/*otherP1*/ varNamePtr, /*otherP2*/ NULL,
/*otherFlags*/ TCL_NAMESPACE_ONLY,
/*myName*/ tail, /*myFlags*/ 0, -1);
if (result != TCL_OK) {
return result;
}
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* Tcl_UpvarObjCmd --
*
* This object-based procedure is invoked to process the "upvar"
* Tcl command. See the user documentation for details on what it does.
*
* Results:
* A standard Tcl object result value.
*
* Side effects:
* See the user documentation.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
Tcl_UpvarObjCmd(dummy, interp, objc, objv)
ClientData dummy; /* Not used. */
Tcl_Interp *interp; /* Current interpreter. */
int objc; /* Number of arguments. */
Tcl_Obj *CONST objv[]; /* Argument objects. */
{
CallFrame *framePtr;
char *frameSpec, *localName;
int result;
if (objc < 3) {
upvarSyntax:
Tcl_WrongNumArgs(interp, 1, objv,
"?level? otherVar localVar ?otherVar localVar ...?");
return TCL_ERROR;
}
/*
* Find the call frame containing each of the "other variables" to be
* linked to.
*/
frameSpec = TclGetString(objv[1]);
result = TclGetFrame(interp, frameSpec, &framePtr);
if (result == -1) {
return TCL_ERROR;
}
objc -= result+1;
if ((objc & 1) != 0) {
goto upvarSyntax;
}
objv += result+1;
/*
* Iterate over each (other variable, local variable) pair.
* Divide the other variable name into two parts, then call
* MakeUpvar to do all the work of linking it to the local variable.
*/
for ( ; objc > 0; objc -= 2, objv += 2) {
localName = TclGetString(objv[1]);
result = ObjMakeUpvar(interp, framePtr, /* othervarName */ objv[0],
NULL, 0, /* myVarName */ localName, /*flags*/ 0, -1);
if (result != TCL_OK) {
return TCL_ERROR;
}
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* DisposeTraceResult--
*
* This procedure is called to dispose of the result returned from
* a trace procedure. The disposal method appropriate to the type
* of result is determined by flags.
*
* Results:
* None.
*
* Side effects:
* The memory allocated for the trace result may be freed.
*
*----------------------------------------------------------------------
*/
static void
DisposeTraceResult(flags, result)
int flags; /* Indicates type of result to determine
* proper disposal method */
char *result; /* The result returned from a trace
* procedure to be disposed */
{
if (flags & TCL_TRACE_RESULT_DYNAMIC) {
ckfree(result);
} else if (flags & TCL_TRACE_RESULT_OBJECT) {
Tcl_DecrRefCount((Tcl_Obj *) result);
}
}
/*
*----------------------------------------------------------------------
*
* CallVarTraces --
*
* 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:
* Returns TCL_OK to indicate normal operation. Returns TCL_ERROR
* if invocation of a trace procedure indicated an error. When
* TCL_ERROR is returned and leaveErrMsg is true, then the
* ::errorInfo variable of iPtr has information about the error
* appended to it.
*
* Side effects:
* Almost anything can happen, depending on trace; this procedure
* itself doesn't have any side effects.
*
*----------------------------------------------------------------------
*/
static int
CallVarTraces(iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg)
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. */
CONST char *part1;
CONST char *part2; /* Variable's two-part name. */
int flags; /* Flags passed to trace procedures:
* indicates what's happening to variable,
* plus other stuff like TCL_GLOBAL_ONLY,
* or TCL_NAMESPACE_ONLY. */
CONST int leaveErrMsg; /* If true, and one of the traces indicates an
* error, then leave an error message and stack
* trace information in *iPTr. */
{
register VarTrace *tracePtr;
ActiveVarTrace active;
char *result;
CONST char *openParen, *p;
Tcl_DString nameCopy;
int copiedName;
int code = TCL_OK;
int disposeFlags = 0;
int saveErrFlags = iPtr->flags
& (ERR_IN_PROGRESS | ERR_ALREADY_LOGGED | ERROR_CODE_SET);
/*
* If there are already similar trace procedures active for the
* variable, don't call them again.
*/
if (varPtr->flags & VAR_TRACE_ACTIVE) {
return code;
}
varPtr->flags |= VAR_TRACE_ACTIVE;
varPtr->refCount++;
if (arrayPtr != NULL) {
arrayPtr->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 (part2 == NULL) {
for (p = part1; *p ; p++) {
if (*p == '(') {
openParen = p;
do {
p++;
} while (*p != '');
p--;
if (*p == ')') {
int offset = (openParen - part1);
char *newPart1;
Tcl_DStringInit(&nameCopy);
Tcl_DStringAppend(&nameCopy, part1, (p-part1));
newPart1 = Tcl_DStringValue(&nameCopy);
newPart1[offset] = 0;
part1 = newPart1;
part2 = newPart1 + offset + 1;
copiedName = 1;
}
break;
}
}
}
/*
* Invoke traces on the array containing the variable, if relevant.
*/
result = NULL;
active.nextPtr = iPtr->activeVarTracePtr;
iPtr->activeVarTracePtr = &active;
Tcl_Preserve((ClientData) iPtr);
if (arrayPtr != NULL && !(arrayPtr->flags & VAR_TRACE_ACTIVE)) {
active.varPtr = arrayPtr;
for (tracePtr = arrayPtr->tracePtr; tracePtr != NULL;
tracePtr = active.nextTracePtr) {
active.nextTracePtr = tracePtr->nextPtr;
if (!(tracePtr->flags & flags)) {
continue;
}
Tcl_Preserve((ClientData) tracePtr);
if (Tcl_InterpDeleted((Tcl_Interp *)iPtr)) {
flags |= TCL_INTERP_DESTROYED;
}
result = (*tracePtr->traceProc)(tracePtr->clientData,
(Tcl_Interp *) iPtr, part1, part2, flags);
if (result != NULL) {
if (flags & TCL_TRACE_UNSETS) {
/* Ignore errors in unset traces */
DisposeTraceResult(tracePtr->flags, result);
} else {
disposeFlags = tracePtr->flags;
code = TCL_ERROR;
}
}
Tcl_Release((ClientData) tracePtr);
if (code == TCL_ERROR) {
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;
}
Tcl_Preserve((ClientData) tracePtr);
if (Tcl_InterpDeleted((Tcl_Interp *)iPtr)) {
flags |= TCL_INTERP_DESTROYED;
}
result = (*tracePtr->traceProc)(tracePtr->clientData,
(Tcl_Interp *) iPtr, part1, part2, flags);
if (result != NULL) {
if (flags & TCL_TRACE_UNSETS) {
/* Ignore errors in unset traces */
DisposeTraceResult(tracePtr->flags, result);
} else {
disposeFlags = tracePtr->flags;
code = TCL_ERROR;
}
}
Tcl_Release((ClientData) tracePtr);
if (code == TCL_ERROR) {
goto done;
}
}
/*
* Restore the variable's flags, remove the record of our active
* traces, and then return.
*/
done:
if (code == TCL_OK) {
iPtr->flags |= saveErrFlags;
}
if (code == TCL_ERROR) {
if (leaveErrMsg) {
CONST char *type = "";
switch (flags&(TCL_TRACE_READS|TCL_TRACE_WRITES|TCL_TRACE_ARRAY)) {
case TCL_TRACE_READS: {
type = "read";
break;
}
case TCL_TRACE_WRITES: {
type = "set";
break;
}
case TCL_TRACE_ARRAY: {
type = "trace array";
break;
}
}
if (disposeFlags & TCL_TRACE_RESULT_OBJECT) {
VarErrMsg((Tcl_Interp *) iPtr, part1, part2, type,
Tcl_GetString((Tcl_Obj *) result));
} else {
VarErrMsg((Tcl_Interp *) iPtr, part1, part2, type, result);
}
}
DisposeTraceResult(disposeFlags,result);
}
if (arrayPtr != NULL) {
arrayPtr->refCount--;
}
if (copiedName) {
Tcl_DStringFree(&nameCopy);
}
varPtr->flags &= ~VAR_TRACE_ACTIVE;
varPtr->refCount--;
iPtr->activeVarTracePtr = active.nextPtr;
Tcl_Release((ClientData) iPtr);
return code;
}
/*
*----------------------------------------------------------------------
*
* NewVar --
*
* Create a new heap-allocated variable that will eventually be
* entered into a hashtable.
*
* Results:
* The return value is a pointer to the new variable structure. It is
* marked as a scalar variable (and not a link or array variable). Its
* value initially is NULL. The variable is not part of any hash table
* yet. Since it will be in a hashtable and not in a call frame, its
* name field is set NULL. It is initially marked as undefined.
*
* Side effects:
* Storage gets allocated.
*
*----------------------------------------------------------------------
*/
static Var *
NewVar()
{
register Var *varPtr;
varPtr = (Var *) ckalloc(sizeof(Var));
varPtr->value.objPtr = NULL;
varPtr->name = NULL;
varPtr->nsPtr = NULL;
varPtr->hPtr = NULL;
varPtr->refCount = 0;
varPtr->tracePtr = NULL;
varPtr->searchPtr = NULL;
varPtr->flags = (VAR_SCALAR | VAR_UNDEFINED | VAR_IN_HASHTABLE);
return varPtr;
}
/*
*----------------------------------------------------------------------
*
* SetArraySearchObj --
*
* This function converts the given tcl object into one that
* has the "array search" internal type.
*
* Results:
* TCL_OK if the conversion succeeded, and TCL_ERROR if it failed
* (when an error message will be placed in the interpreter's
* result.)
*
* Side effects:
* Updates the internal type and representation of the object to
* make this an array-search object. See the tclArraySearchType
* declaration above for details of the internal representation.
*
*----------------------------------------------------------------------
*/
static int
SetArraySearchObj(interp, objPtr)
Tcl_Interp *interp;
Tcl_Obj *objPtr;
{
char *string;
char *end;
int id;
size_t offset;
/*
* Get the string representation. Make it up-to-date if necessary.
*/
string = Tcl_GetString(objPtr);
/*
* 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 TCL_ERROR;
}
id = strtoul(string+2, &end, 10);
if ((end == (string+2)) || (*end != '-')) {
goto syntax;
}
/*
* Can't perform value check in this context, so place reference
* to place in string to use for the check in the object instead.
*/
end++;
offset = end - string;
if (objPtr->typePtr != NULL && objPtr->typePtr->freeIntRepProc != NULL) {
objPtr->typePtr->freeIntRepProc(objPtr);
}
objPtr->typePtr = &tclArraySearchType;
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *)(((char *)NULL)+id);
objPtr->internalRep.twoPtrValue.ptr2 = (VOID *)(((char *)NULL)+offset);
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* ParseSearchId --
*
* This procedure translates from a tcl object 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,
* the interp's result contains an error message.
*
* Side effects:
* The tcl object might have its internal type and representation
* modified.
*
*----------------------------------------------------------------------
*/
static ArraySearch *
ParseSearchId(interp, varPtr, varName, handleObj)
Tcl_Interp *interp; /* Interpreter containing variable. */
CONST Var *varPtr; /* Array variable search is for. */
CONST char *varName; /* Name of array variable that search is
* supposed to be for. */
Tcl_Obj *handleObj; /* Object containing id of search. Must have
* form "search-num-var" where "num" is a
* decimal number and "var" is a variable
* name. */
{
register char *string;
register size_t offset;
int id;
ArraySearch *searchPtr;
/*
* Parse the id.
*/
if (Tcl_ConvertToType(interp, handleObj, &tclArraySearchType) != TCL_OK) {
return NULL;
}
/*
* Cast is safe, since always came from an int in the first place.
*/
id = (int)(((char*)handleObj->internalRep.twoPtrValue.ptr1) -
((char*)NULL));
string = Tcl_GetString(handleObj);
offset = (((char*)handleObj->internalRep.twoPtrValue.ptr2) -
((char*)NULL));
/*
* This test cannot be placed inside the Tcl_Obj machinery, since
* it is dependent on the variable context.
*/
if (strcmp(string+offset, 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.
*
* Note that we cannot store the searchPtr directly in the Tcl_Obj
* as that would run into trouble when DeleteSearches() was called
* so we must scan this list every time.
*/
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);
}
}
/*
*----------------------------------------------------------------------
*
* TclDeleteNamespaceVars --
*
* This procedure is called to recycle all the storage space
* associated with a namespace's table of variables.
*
* Results:
* None.
*
* Side effects:
* Variables are deleted and trace procedures are invoked, if
* any are declared.
*
*----------------------------------------------------------------------
*/
void
TclDeleteNamespaceVars(nsPtr)
Namespace *nsPtr;
{
Tcl_HashTable *tablePtr = &nsPtr->varTable;
Tcl_Interp *interp = nsPtr->interp;
Interp *iPtr = (Interp *)interp;
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
int flags = 0;
Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
/*
* Determine what flags to pass to the trace callback procedures.
*/
if (nsPtr == iPtr->globalNsPtr) {
flags = TCL_GLOBAL_ONLY;
} else if (nsPtr == currNsPtr) {
flags = TCL_NAMESPACE_ONLY;
}
for (hPtr = Tcl_FirstHashEntry(tablePtr, &search); hPtr != NULL;
hPtr = Tcl_FirstHashEntry(tablePtr, &search)) {
register Var *varPtr = (Var *) Tcl_GetHashValue(hPtr);
Tcl_Obj *objPtr = Tcl_NewObj();
varPtr->refCount++; /* Make sure we get to remove from hash */
Tcl_IncrRefCount(objPtr);
Tcl_GetVariableFullName(interp, (Tcl_Var) varPtr, objPtr);
UnsetVarStruct(varPtr, NULL, iPtr, Tcl_GetString(objPtr), NULL, flags);
Tcl_DecrRefCount(objPtr); /* free no longer needed obj */
varPtr->refCount--;
/* Remove the variable from the table and force it undefined
* in case an unset trace brought it back from the dead */
Tcl_DeleteHashEntry(hPtr);
varPtr->hPtr = NULL;
TclSetVarUndefined(varPtr);
TclSetVarScalar(varPtr);
while (varPtr->tracePtr != NULL) {
VarTrace *tracePtr = varPtr->tracePtr;
varPtr->tracePtr = tracePtr->nextPtr;
Tcl_EventuallyFree((ClientData) tracePtr, TCL_DYNAMIC);
}
CleanupVar(varPtr, NULL);
}
Tcl_DeleteHashTable(tablePtr);
}
/*
*----------------------------------------------------------------------
*
* 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
* variables 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_Interp *interp = (Tcl_Interp *) iPtr;
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
register Var *varPtr;
Var *linkPtr;
int flags;
ActiveVarTrace *activePtr;
Tcl_Obj *objPtr;
Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
/*
* Determine what flags to pass to the trace callback procedures.
*/
flags = TCL_TRACE_UNSETS;
if (tablePtr == &iPtr->globalNsPtr->varTable) {
flags |= TCL_GLOBAL_ONLY;
} else if (tablePtr == &currNsPtr->varTable) {
flags |= TCL_NAMESPACE_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 (TclIsVarLink(varPtr)) {
linkPtr = varPtr->value.linkPtr;
linkPtr->refCount--;
if ((linkPtr->refCount == 0) && TclIsVarUndefined(linkPtr)
&& (linkPtr->tracePtr == NULL)
&& (linkPtr->flags & VAR_IN_HASHTABLE)) {
if (linkPtr->hPtr == NULL) {
ckfree((char *) linkPtr);
} else if (linkPtr->hPtr->tablePtr != tablePtr) {
Tcl_DeleteHashEntry(linkPtr->hPtr);
ckfree((char *) linkPtr);
}
}
}
/*
* 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). Note that we give CallVarTraces the variable's
* fully-qualified name so that any called trace procedures can
* refer to these variables being deleted.
*/
if (varPtr->tracePtr != NULL) {
objPtr = Tcl_NewObj();
Tcl_IncrRefCount(objPtr); /* until done with traces */
Tcl_GetVariableFullName(interp, (Tcl_Var) varPtr, objPtr);
CallVarTraces(iPtr, (Var *) NULL, varPtr, Tcl_GetString(objPtr),
NULL, flags, /* leaveErrMsg */ 0);
Tcl_DecrRefCount(objPtr); /* free no longer needed obj */
while (varPtr->tracePtr != NULL) {
VarTrace *tracePtr = varPtr->tracePtr;
varPtr->tracePtr = tracePtr->nextPtr;
Tcl_EventuallyFree((ClientData) tracePtr, TCL_DYNAMIC);
}
for (activePtr = iPtr->activeVarTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == varPtr) {
activePtr->nextTracePtr = NULL;
}
}
}
if (TclIsVarArray(varPtr)) {
DeleteArray(iPtr, Tcl_GetHashKey(tablePtr, hPtr), varPtr,
flags);
varPtr->value.tablePtr = NULL;
}
if (TclIsVarScalar(varPtr) && (varPtr->value.objPtr != NULL)) {
objPtr = varPtr->value.objPtr;
TclDecrRefCount(objPtr);
varPtr->value.objPtr = NULL;
}
varPtr->hPtr = NULL;
varPtr->tracePtr = NULL;
TclSetVarUndefined(varPtr);
TclSetVarScalar(varPtr);
/*
* If the variable was a namespace variable, decrement its
* reference count. We are in the process of destroying its
* namespace so that namespace will no longer "refer" to the
* variable.
*/
if (varPtr->flags & VAR_NAMESPACE_VAR) {
varPtr->flags &= ~VAR_NAMESPACE_VAR;
varPtr->refCount--;
}
/*
* Recycle the variable's memory space if there aren't any upvar's
* pointing to it. If there are upvars to this variable, then the
* variable will get freed when the last upvar goes away.
*/
if (varPtr->refCount == 0) {
ckfree((char *) varPtr); /* this Var must be VAR_IN_HASHTABLE */
}
}
Tcl_DeleteHashTable(tablePtr);
}
/*
*----------------------------------------------------------------------
*
* TclDeleteCompiledLocalVars --
*
* This procedure is called to recycle storage space associated with
* the compiler-allocated array of local variables in a procedure call
* frame. This procedure resembles TclDeleteVars above except that each
* variable is stored in a call frame and not a hash table. 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
TclDeleteCompiledLocalVars(iPtr, framePtr)
Interp *iPtr; /* Interpreter to which variables belong. */
CallFrame *framePtr; /* Procedure call frame containing
* compiler-assigned local variables to
* delete. */
{
register Var *varPtr;
int flags; /* Flags passed to trace procedures. */
Var *linkPtr;
ActiveVarTrace *activePtr;
int numLocals, i;
flags = TCL_TRACE_UNSETS;
numLocals = framePtr->numCompiledLocals;
varPtr = framePtr->compiledLocals;
for (i = 0; i < numLocals; i++) {
/*
* 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 (TclIsVarLink(varPtr)) {
linkPtr = varPtr->value.linkPtr;
linkPtr->refCount--;
if ((linkPtr->refCount == 0) && TclIsVarUndefined(linkPtr)
&& (linkPtr->tracePtr == NULL)
&& (linkPtr->flags & VAR_IN_HASHTABLE)) {
if (linkPtr->hPtr == NULL) {
ckfree((char *) linkPtr);
} else {
Tcl_DeleteHashEntry(linkPtr->hPtr);
ckfree((char *) linkPtr);
}
}
}
/*
* Invoke traces on the variable that is being deleted. Then delete
* the variable's trace records.
*/
if (varPtr->tracePtr != NULL) {
CallVarTraces(iPtr, (Var *) NULL, varPtr, varPtr->name, NULL,
flags, /* leaveErrMsg */ 0);
while (varPtr->tracePtr != NULL) {
VarTrace *tracePtr = varPtr->tracePtr;
varPtr->tracePtr = tracePtr->nextPtr;
Tcl_EventuallyFree((ClientData) tracePtr, TCL_DYNAMIC);
}
for (activePtr = iPtr->activeVarTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == varPtr) {
activePtr->nextTracePtr = NULL;
}
}
}
/*
* Now if the variable is an array, delete its element hash table.
* Otherwise, if it's a scalar variable, decrement the ref count
* of its value.
*/
if (TclIsVarArray(varPtr) && (varPtr->value.tablePtr != NULL)) {
DeleteArray(iPtr, varPtr->name, varPtr, flags);
}
if (TclIsVarScalar(varPtr) && (varPtr->value.objPtr != NULL)) {
TclDecrRefCount(varPtr->value.objPtr);
varPtr->value.objPtr = NULL;
}
varPtr->hPtr = NULL;
varPtr->tracePtr = NULL;
TclSetVarUndefined(varPtr);
TclSetVarScalar(varPtr);
varPtr++;
}
}
/*
*----------------------------------------------------------------------
*
* 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 array's hash table). Deletion trace procedures for
* array elements are invoked, then deleted. Any pending traces for
* array elements are also deleted.
*
*----------------------------------------------------------------------
*/
static void
DeleteArray(iPtr, arrayName, varPtr, flags)
Interp *iPtr; /* Interpreter containing array. */
CONST char *arrayName; /* Name of array (used for trace
* callbacks). */
Var *varPtr; /* Pointer to variable structure. */
int flags; /* Flags to pass to CallVarTraces:
* TCL_TRACE_UNSETS and sometimes
* TCL_NAMESPACE_ONLY, or
* TCL_GLOBAL_ONLY. */
{
Tcl_HashSearch search;
register Tcl_HashEntry *hPtr;
register Var *elPtr;
ActiveVarTrace *activePtr;
Tcl_Obj *objPtr;
DeleteSearches(varPtr);
for (hPtr = Tcl_FirstHashEntry(varPtr->value.tablePtr, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
elPtr = (Var *) Tcl_GetHashValue(hPtr);
if (TclIsVarScalar(elPtr) && (elPtr->value.objPtr != NULL)) {
objPtr = elPtr->value.objPtr;
TclDecrRefCount(objPtr);
elPtr->value.objPtr = NULL;
}
elPtr->hPtr = NULL;
if (elPtr->tracePtr != NULL) {
elPtr->flags &= ~VAR_TRACE_ACTIVE;
CallVarTraces(iPtr, (Var *) NULL, elPtr, arrayName,
Tcl_GetHashKey(varPtr->value.tablePtr, hPtr), flags,
/* leaveErrMsg */ 0);
while (elPtr->tracePtr != NULL) {
VarTrace *tracePtr = elPtr->tracePtr;
elPtr->tracePtr = tracePtr->nextPtr;
Tcl_EventuallyFree((ClientData) tracePtr,TCL_DYNAMIC);
}
for (activePtr = iPtr->activeVarTracePtr; activePtr != NULL;
activePtr = activePtr->nextPtr) {
if (activePtr->varPtr == elPtr) {
activePtr->nextTracePtr = NULL;
}
}
}
TclSetVarUndefined(elPtr);
TclSetVarScalar(elPtr);
/*
* Even though array elements are not supposed to be namespace
* variables, some combinations of [upvar] and [variable] may
* create such beasts - see [Bug 604239]. This is necessary to
* avoid leaking the corresponding Var struct, and is otherwise
* harmless.
*/
if (elPtr->flags & VAR_NAMESPACE_VAR) {
elPtr->flags &= ~VAR_NAMESPACE_VAR;
elPtr->refCount--;
}
if (elPtr->refCount == 0) {
ckfree((char *) elPtr); /* element Vars are VAR_IN_HASHTABLE */
}
}
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
* a variable's storage. If the variable is in a hashtable, its Var
* structure and hash table entry will be freed along with those of its
* containing array, if any. This procedure is called, for example,
* when a trace on a variable deletes a variable.
*
* Results:
* None.
*
* Side effects:
* If the variable (or its containing array) really is dead and in a
* hashtable, then its Var structure, and possibly its hash table
* entry, is 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 (TclIsVarUndefined(varPtr) && (varPtr->refCount == 0)
&& (varPtr->tracePtr == NULL)
&& (varPtr->flags & VAR_IN_HASHTABLE)) {
if (varPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(varPtr->hPtr);
}
ckfree((char *) varPtr);
}
if (arrayPtr != NULL) {
if (TclIsVarUndefined(arrayPtr) && (arrayPtr->refCount == 0)
&& (arrayPtr->tracePtr == NULL)
&& (arrayPtr->flags & VAR_IN_HASHTABLE)) {
if (arrayPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(arrayPtr->hPtr);
}
ckfree((char *) arrayPtr);
}
}
}
/*
*----------------------------------------------------------------------
*
* VarErrMsg --
*
* Generate a reasonable error message describing why a variable
* operation failed.
*
* Results:
* None.
*
* Side effects:
* The interp's result is set 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. */
CONST char *part1;
CONST char *part2; /* Variable's two-part name. */
CONST char *operation; /* String describing operation that failed,
* e.g. "read", "set", or "unset". */
CONST 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);
}
/*
*----------------------------------------------------------------------
*
* TclTraceVarExists --
*
* This is called from info exists. We need to trigger read
* and/or array traces because they may end up creating a
* variable that doesn't currently exist.
*
* Results:
* A pointer to the Var structure, or NULL.
*
* Side effects:
* May fill in error messages in the interp.
*
*----------------------------------------------------------------------
*/
Var *
TclVarTraceExists(interp, varName)
Tcl_Interp *interp; /* The interpreter */
CONST char *varName; /* The variable name */
{
Var *varPtr;
Var *arrayPtr;
/*
* The choice of "create" flag values is delicate here, and
* matches the semantics of GetVar. Things are still not perfect,
* however, because if you do "info exists x" you get a varPtr
* and therefore trigger traces. However, if you do
* "info exists x(i)", then you only get a varPtr if x is already
* known to be an array. Otherwise you get NULL, and no trace
* is triggered. This matches Tcl 7.6 semantics.
*/
varPtr = TclLookupVar(interp, varName, (char *) NULL,
0, "access", /*createPart1*/ 0, /*createPart2*/ 1, &arrayPtr);
if (varPtr == NULL) {
return NULL;
}
if ((varPtr->tracePtr != NULL)
|| ((arrayPtr != NULL) && (arrayPtr->tracePtr != NULL))) {
CallVarTraces((Interp *)interp, arrayPtr, varPtr, varName, NULL,
TCL_TRACE_READS, /* leaveErrMsg */ 0);
}
/*
* If the variable doesn't exist anymore and no-one's using
* it, then free up the relevant structures and hash table entries.
*/
if (TclIsVarUndefined(varPtr)) {
CleanupVar(varPtr, arrayPtr);
return NULL;
}
return varPtr;
}
/*
*----------------------------------------------------------------------
*
* Internal functions for variable name object types --
*
*----------------------------------------------------------------------
*/
/*
* localVarName -
*
* INTERNALREP DEFINITION:
* twoPtrValue.ptr1 = pointer to the corresponding Proc
* twoPtrValue.ptr2 = index into locals table
*/
static void
FreeLocalVarName(objPtr)
Tcl_Obj *objPtr;
{
register Proc *procPtr = (Proc *) objPtr->internalRep.twoPtrValue.ptr1;
procPtr->refCount--;
if (procPtr->refCount <= 0) {
TclProcCleanupProc(procPtr);
}
}
static void
DupLocalVarName(srcPtr, dupPtr)
Tcl_Obj *srcPtr;
Tcl_Obj *dupPtr;
{
register Proc *procPtr = (Proc *) srcPtr->internalRep.twoPtrValue.ptr1;
dupPtr->internalRep.twoPtrValue.ptr1 = (VOID *) procPtr;
dupPtr->internalRep.twoPtrValue.ptr2 = srcPtr->internalRep.twoPtrValue.ptr2;
procPtr->refCount++;
dupPtr->typePtr = &tclLocalVarNameType;
}
static void
UpdateLocalVarName(objPtr)
Tcl_Obj *objPtr;
{
Proc *procPtr = (Proc *) objPtr->internalRep.twoPtrValue.ptr1;
unsigned int index = (unsigned int) objPtr->internalRep.twoPtrValue.ptr2;
CompiledLocal *localPtr = procPtr->firstLocalPtr;
unsigned int nameLen;
if (localPtr == NULL) {
goto emptyName;
}
while (index--) {
localPtr = localPtr->nextPtr;
if (localPtr == NULL) {
goto emptyName;
}
}
nameLen = (unsigned int) localPtr->nameLength;
objPtr->bytes = ckalloc(nameLen + 1);
memcpy(objPtr->bytes, localPtr->name, nameLen + 1);
objPtr->length = nameLen;
return;
emptyName:
objPtr->bytes = ckalloc(1);
*(objPtr->bytes) = '';
objPtr->length = 0;
}
/*
* nsVarName -
*
* INTERNALREP DEFINITION:
* twoPtrValue.ptr1: pointer to the namespace containing the
* reference.
* twoPtrValue.ptr2: pointer to the corresponding Var
*/
static void
FreeNsVarName(objPtr)
Tcl_Obj *objPtr;
{
register Var *varPtr = (Var *) objPtr->internalRep.twoPtrValue.ptr2;
varPtr->refCount--;
if (TclIsVarUndefined(varPtr) && (varPtr->refCount <= 0)) {
if (TclIsVarLink(varPtr)) {
Var *linkPtr = varPtr->value.linkPtr;
linkPtr->refCount--;
if (TclIsVarUndefined(linkPtr) && (linkPtr->refCount <= 0)) {
CleanupVar(linkPtr, (Var *) NULL);
}
}
CleanupVar(varPtr, NULL);
}
}
static void
DupNsVarName(srcPtr, dupPtr)
Tcl_Obj *srcPtr;
Tcl_Obj *dupPtr;
{
Namespace *nsPtr = (Namespace *) srcPtr->internalRep.twoPtrValue.ptr1;
register Var *varPtr = (Var *) srcPtr->internalRep.twoPtrValue.ptr2;
dupPtr->internalRep.twoPtrValue.ptr1 = (VOID *) nsPtr;
dupPtr->internalRep.twoPtrValue.ptr2 = (VOID *) varPtr;
varPtr->refCount++;
dupPtr->typePtr = &tclNsVarNameType;
}
/*
* parsedVarName -
*
* INTERNALREP DEFINITION:
* twoPtrValue.ptr1 = pointer to the array name Tcl_Obj
* (NULL if scalar)
* twoPtrValue.ptr2 = pointer to the element name string
* (owned by this Tcl_Obj), or NULL if
* it is a scalar variable
*/
static void
FreeParsedVarName(objPtr)
Tcl_Obj *objPtr;
{
register Tcl_Obj *arrayPtr =
(Tcl_Obj *) objPtr->internalRep.twoPtrValue.ptr1;
register char *elem = (char *) objPtr->internalRep.twoPtrValue.ptr2;
if (arrayPtr != NULL) {
TclDecrRefCount(arrayPtr);
ckfree(elem);
}
}
static void
DupParsedVarName(srcPtr, dupPtr)
Tcl_Obj *srcPtr;
Tcl_Obj *dupPtr;
{
register Tcl_Obj *arrayPtr =
(Tcl_Obj *) srcPtr->internalRep.twoPtrValue.ptr1;
register char *elem = (char *) srcPtr->internalRep.twoPtrValue.ptr2;
char *elemCopy;
unsigned int elemLen;
if (arrayPtr != NULL) {
Tcl_IncrRefCount(arrayPtr);
elemLen = strlen(elem);
elemCopy = ckalloc(elemLen+1);
memcpy(elemCopy, elem, elemLen);
*(elemCopy + elemLen) = '';
elem = elemCopy;
}
dupPtr->internalRep.twoPtrValue.ptr1 = (VOID *) arrayPtr;
dupPtr->internalRep.twoPtrValue.ptr2 = (VOID *) elem;
dupPtr->typePtr = &tclParsedVarNameType;
}
static void
UpdateParsedVarName(objPtr)
Tcl_Obj *objPtr;
{
Tcl_Obj *arrayPtr = (Tcl_Obj *) objPtr->internalRep.twoPtrValue.ptr1;
char *part2 = (char *) objPtr->internalRep.twoPtrValue.ptr2;
char *part1, *p;
int len1, len2, totalLen;
if (arrayPtr == NULL) {
/*
* This is a parsed scalar name: what is it
* doing here?
*/
panic("ERROR: scalar parsedVarName without a string rep.n");
}
part1 = Tcl_GetStringFromObj(arrayPtr, &len1);
len2 = strlen(part2);
totalLen = len1 + len2 + 2;
p = ckalloc((unsigned int) totalLen + 1);
objPtr->bytes = p;
objPtr->length = totalLen;
memcpy(p, part1, (unsigned int) len1);
p += len1;
*p++ = '(';
memcpy(p, part2, (unsigned int) len2);
p += len2;
*p++ = ')';
*p = '';
}