static void
FreeCursor(
TkCursor *cursorPtr) /* Cursor to be released. */
{
TkCursor *prevPtr;
cursorPtr->resourceRefCount--;
if (cursorPtr->resourceRefCount > 0) {
return;
}
Tcl_DeleteHashEntry(cursorPtr->idHashPtr);
prevPtr = (TkCursor *) Tcl_GetHashValue(cursorPtr->hashPtr);
if (prevPtr == cursorPtr) {
if (cursorPtr->nextPtr == NULL) {
Tcl_DeleteHashEntry(cursorPtr->hashPtr);
} else {
Tcl_SetHashValue(cursorPtr->hashPtr, cursorPtr->nextPtr);
}
} else {
while (prevPtr->nextPtr != cursorPtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = cursorPtr->nextPtr;
}
TkpFreeCursor(cursorPtr);
if (cursorPtr->objRefCount == 0) {
ckfree((char *) cursorPtr);
}
}
void
TkGCCleanup(
TkDisplay *dispPtr) /* display to clean up resources in */
{
Tcl_HashEntry *entryPtr;
Tcl_HashSearch search;
TkGC *gcPtr;
for (entryPtr = Tcl_FirstHashEntry(&dispPtr->gcIdTable, &search);
entryPtr != NULL; entryPtr = Tcl_NextHashEntry(&search)) {
gcPtr = Tcl_GetHashValue(entryPtr);
/*
* This call is not needed, as it is only used on Unix to restore the
* Id to the stack pool, and we don't want to use them anymore.
* Tk_FreeXId(gcPtr->display, (XID) XGContextFromGC(gcPtr->gc));
*/
XFreeGC(gcPtr->display, gcPtr->gc);
Tcl_DeleteHashEntry(gcPtr->valueHashPtr);
Tcl_DeleteHashEntry(entryPtr);
ckfree(gcPtr);
}
Tcl_DeleteHashTable(&dispPtr->gcValueTable);
Tcl_DeleteHashTable(&dispPtr->gcIdTable);
dispPtr->gcInit = -1;
}
int DBus_SignalCleanup(Tcl_Interp *interp, Tcl_HashTable *members)
{
Tcl_HashTable *interps;
Tcl_HashEntry *memberPtr, *interpPtr;
Tcl_HashSearch search;
Tcl_DBusSignalData *signal;
for (memberPtr = Tcl_FirstHashEntry(members, &search);
memberPtr != NULL; memberPtr = Tcl_NextHashEntry(&search)) {
interps = Tcl_GetHashValue(memberPtr);
interpPtr = Tcl_FindHashEntry(interps, (char *) interp);
if (interpPtr != NULL) {
signal = Tcl_GetHashValue(interpPtr);
Tcl_DecrRefCount(signal->script);
ckfree((char *) signal);
Tcl_DeleteHashEntry(interpPtr);
if (Tcl_CheckHashEmpty(interps)) {
Tcl_DeleteHashTable(interps);
ckfree((char *) interps);
Tcl_DeleteHashEntry(memberPtr);
}
}
}
return Tcl_CheckHashEmpty(members);
}
static void
FreeBitmap(
TkBitmap *bitmapPtr) /* Bitmap to be released. */
{
TkBitmap *prevPtr;
bitmapPtr->resourceRefCount--;
if (bitmapPtr->resourceRefCount > 0) {
return;
}
Tk_FreePixmap(bitmapPtr->display, bitmapPtr->bitmap);
Tcl_DeleteHashEntry(bitmapPtr->idHashPtr);
prevPtr = Tcl_GetHashValue(bitmapPtr->nameHashPtr);
if (prevPtr == bitmapPtr) {
if (bitmapPtr->nextPtr == NULL) {
Tcl_DeleteHashEntry(bitmapPtr->nameHashPtr);
} else {
Tcl_SetHashValue(bitmapPtr->nameHashPtr, bitmapPtr->nextPtr);
}
} else {
while (prevPtr->nextPtr != bitmapPtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = bitmapPtr->nextPtr;
}
if (bitmapPtr->objRefCount == 0) {
ckfree(bitmapPtr);
}
}
static void
DeleteImage(
ImageMaster *masterPtr) /* Pointer to main data structure for image. */
{
Image *imagePtr;
Tk_ImageType *typePtr;
typePtr = masterPtr->typePtr;
masterPtr->typePtr = NULL;
if (typePtr != NULL) {
for (imagePtr = masterPtr->instancePtr; imagePtr != NULL;
imagePtr = imagePtr->nextPtr) {
typePtr->freeProc(imagePtr->instanceData, imagePtr->display);
imagePtr->changeProc(imagePtr->widgetClientData, 0, 0,
masterPtr->width, masterPtr->height, masterPtr->width,
masterPtr->height);
}
typePtr->deleteProc(masterPtr->masterData);
}
if (masterPtr->instancePtr == NULL) {
if (masterPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(masterPtr->hPtr);
}
Tcl_Release(masterPtr->winPtr);
ckfree(masterPtr);
} else {
masterPtr->deleted = 1;
}
}
void
XOTclProfilePrintTable(Tcl_HashTable* table) {
Tcl_HashEntry* topValueHPtr;
long int* topValue;
do {
Tcl_HashSearch hSrch;
Tcl_HashEntry* hPtr = table ?
Tcl_FirstHashEntry(table, &hSrch) : 0;
char* topKey = 0;
topValueHPtr = 0;
topValue = 0;
for (; hPtr != 0; hPtr = Tcl_NextHashEntry(&hSrch)) {
long int *val = (long int*) Tcl_GetHashValue(hPtr);
if (val && (!topValue || (topValue && *val >= *topValue))) {
topValue = val;
topValueHPtr = hPtr;
topKey = Tcl_GetHashKey(table, hPtr);
}
}
if (topValueHPtr) {
fprintf(stderr, " %15ld %s\n", *topValue, topKey);
ckfree((char*) topValue);
Tcl_DeleteHashEntry(topValueHPtr);
}
} while (topValueHPtr);
}
////////////////////////////////////////////////////
// cleanup any leftover registration
////////////////////////////////////////////////////
static int bonjour_register_cleanup(
ClientData clientData
) {
Tcl_HashTable *registerRegistrations =
(Tcl_HashTable *)clientData;
Tcl_HashEntry *hashEntry = NULL;
Tcl_HashSearch searchToken;
active_registration *activeRegister = NULL;
// run through the remaining entries in the hash table
for(hashEntry = Tcl_FirstHashEntry(registerRegistrations,
&searchToken);
hashEntry != NULL;
hashEntry = Tcl_NextHashEntry(&searchToken)) {
activeRegister = (active_registration *)Tcl_GetHashValue(hashEntry);
// deallocate the service reference
DNSServiceRefDeallocate(activeRegister->sdRef);
// clean up the memory used by activeRegister
ckfree(activeRegister->regtype);
ckfree((void *)activeRegister);
// deallocate the hash entry
Tcl_DeleteHashEntry(hashEntry);
}
Tcl_DeleteHashTable(registerRegistrations);
return(TCL_OK);
}
static AP_Result tcl_delete(AP_World *w, AP_Obj interp_name)
{
Tcl_HashEntry *entry;
Tcl_Interp *interp;
if (AP_ObjType(w, interp_name) != AP_ATOM) {
return AP_SetStandardError(w, AP_TYPE_ERROR,
AP_NewSymbolFromStr(w, "atom"), interp_name);
}
entry = Tcl_FindHashEntry(&tcl_interp_name_table, AP_GetAtomStr(w, interp_name));
if (!entry) {
return AP_SetStandardError(w, AP_DOMAIN_ERROR,
AP_NewSymbolFromStr(w, "tcl_interpreter"), interp_name);
}
interp = Tcl_GetHashValue(entry);
Tcl_DeleteInterp(interp);
Tcl_DeleteHashEntry(entry);
return AP_SUCCESS;
}
static void
EmbWinStructureProc(
ClientData clientData, /* Pointer to record describing window item. */
XEvent *eventPtr) /* Describes what just happened. */
{
TkTextEmbWindowClient *client = clientData;
TkTextSegment *ewPtr = client->parent;
TkTextIndex index;
Tcl_HashEntry *hPtr;
if (eventPtr->type != DestroyNotify) {
return;
}
hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
if (hPtr != NULL) {
/*
* This may not exist if the entire widget is being deleted.
*/
Tcl_DeleteHashEntry(hPtr);
}
ewPtr->body.ew.tkwin = NULL;
client->tkwin = NULL;
index.tree = ewPtr->body.ew.sharedTextPtr->tree;
index.linePtr = ewPtr->body.ew.linePtr;
index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index);
TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL,
index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY);
}
void
Tk_FreeColor(
XColor *colorPtr) /* Color to be released. Must have been
* allocated by Tk_GetColor or
* Tk_GetColorByValue. */
{
TkColor *tkColPtr = (TkColor *) colorPtr;
Screen *screen = tkColPtr->screen;
TkColor *prevPtr;
/*
* Do a quick sanity check to make sure this color was really allocated by
* Tk_GetColor.
*/
if (tkColPtr->magic != COLOR_MAGIC) {
Tcl_Panic("Tk_FreeColor called with bogus color");
}
tkColPtr->resourceRefCount--;
if (tkColPtr->resourceRefCount > 0) {
return;
}
/*
* This color is no longer being actively used, so free the color
* resources associated with it and remove it from the hash table. No
* longer any objects referencing it.
*/
if (tkColPtr->gc != None) {
XFreeGC(DisplayOfScreen(screen), tkColPtr->gc);
tkColPtr->gc = None;
}
TkpFreeColor(tkColPtr);
prevPtr = Tcl_GetHashValue(tkColPtr->hashPtr);
if (prevPtr == tkColPtr) {
if (tkColPtr->nextPtr == NULL) {
Tcl_DeleteHashEntry(tkColPtr->hashPtr);
} else {
Tcl_SetHashValue(tkColPtr->hashPtr, tkColPtr->nextPtr);
}
} else {
while (prevPtr->nextPtr != tkColPtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = tkColPtr->nextPtr;
}
/*
* Free the TkColor structure if there are no objects referencing it.
* However, if there are objects referencing it then keep the structure
* around; it will get freed when the last reference is cleared
*/
if (tkColPtr->objRefCount == 0) {
ckfree((char *) tkColPtr);
}
}
static void
IvyAppCB(IvyClientPtr app,
void *user_data, /* script a appeler */
IvyApplicationEvent event)
{
static const char *app_event_str[] = {
"Connected", "Disconnected" };
filter_struct *filter = (filter_struct *) user_data;
int result, size, dummy;
char *script_to_call;
Tcl_HashEntry *entry;
entry = Tcl_FindHashEntry(&app_table, IvyGetApplicationName(app));
if (event == IvyApplicationConnected) {
if (!entry) {
entry = Tcl_CreateHashEntry(&app_table, IvyGetApplicationName(app), &dummy);
Tcl_SetHashValue(entry, (ClientData) app);
}
}
size = strlen(filter->script) + INTEGER_SPACE;
if (entry) {
size += strlen(IvyGetApplicationName(app)) + 3;
}
else {
size += 4;
}
script_to_call = ckalloc(size);
strcpy(script_to_call, filter->script);
strcat(script_to_call, " ");
if (entry) {
strcat(script_to_call, " \"");
strcat(script_to_call, IvyGetApplicationName(app));
strcat(script_to_call, "\"");
}
else {
strcat(script_to_call, "???");
}
strcat(script_to_call, " \"");
strcat(script_to_call, app_event_str[event%2]);
strcat(script_to_call, "\"");
Tcl_Preserve(filter->interp);
result = Tcl_GlobalEval(filter->interp, script_to_call);
ckfree(script_to_call);
if (result != TCL_OK) {
Tcl_BackgroundError(filter->interp);
}
Tcl_Release(filter->interp);
if (event == IvyApplicationDisconnected) {
if (entry) {
Tcl_DeleteHashEntry(entry);
}
}
}
void
ObjToRepMap::erase (Tcl_Obj *pObj)
{
Tcl_HashEntry *pEntry = Tcl_FindHashEntry(
&m_objMap, reinterpret_cast<char *>(pObj));
if (pEntry != 0) {
Tcl_DeleteHashEntry(pEntry);
}
}
extern int
XOTclUnsetObjectData(XOTclObject* obj, XOTclClass* cl) {
Tcl_HashEntry *hPtr;
if (!cl->opt || !cl->opt->objectdata)
return 0;
hPtr = Tcl_FindHashEntry(cl->opt->objectdata, (char*)obj);
if (hPtr) Tcl_DeleteHashEntry(hPtr);
return hPtr != 0;
}
SWIG_Tcl_Disown(void *ptr) {
Tcl_HashEntry *entryPtr;
if (!swigobjectTableinit) return 0;
entryPtr = Tcl_FindHashEntry(&swigobjectTable, (char *) ptr);
if (entryPtr) {
Tcl_DeleteHashEntry(entryPtr);
return 1;
}
return 0;
}
void
Tfp_ArrayDelete( Tfp_ArrayType *arr, char *key )
{
Tcl_HashEntry *p;
p = Tcl_FindHashEntry( arr->table, key );
if (p == (Tcl_HashEntry *) NULL) {
return;
}
(*arr->cleanProc) ( Tcl_GetHashValue( p ) );
Tcl_DeleteHashEntry( p );
}
static void
PkguaDeleteTokens(
Tcl_Interp *interp)
{
Tcl_HashEntry *entryPtr =
Tcl_FindHashEntry(&interpTokenMap, (char *) interp);
if (entryPtr) {
Tcl_Free((char *) Tcl_GetHashValue(entryPtr));
Tcl_DeleteHashEntry(entryPtr);
}
}
void
Tk_Free3DBorder(
Tk_3DBorder border) /* Token for border to be released. */
{
TkBorder *borderPtr = (TkBorder *) border;
Display *display = DisplayOfScreen(borderPtr->screen);
TkBorder *prevPtr;
borderPtr->resourceRefCount--;
if (borderPtr->resourceRefCount > 0) {
return;
}
prevPtr = (TkBorder *) Tcl_GetHashValue(borderPtr->hashPtr);
TkpFreeBorder(borderPtr);
if (borderPtr->bgColorPtr != NULL) {
Tk_FreeColor(borderPtr->bgColorPtr);
}
if (borderPtr->darkColorPtr != NULL) {
Tk_FreeColor(borderPtr->darkColorPtr);
}
if (borderPtr->lightColorPtr != NULL) {
Tk_FreeColor(borderPtr->lightColorPtr);
}
if (borderPtr->shadow != None) {
Tk_FreeBitmap(display, borderPtr->shadow);
}
if (borderPtr->bgGC != None) {
Tk_FreeGC(display, borderPtr->bgGC);
}
if (borderPtr->darkGC != None) {
Tk_FreeGC(display, borderPtr->darkGC);
}
if (borderPtr->lightGC != None) {
Tk_FreeGC(display, borderPtr->lightGC);
}
if (prevPtr == borderPtr) {
if (borderPtr->nextPtr == NULL) {
Tcl_DeleteHashEntry(borderPtr->hashPtr);
} else {
Tcl_SetHashValue(borderPtr->hashPtr, borderPtr->nextPtr);
}
} else {
while (prevPtr->nextPtr != borderPtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = borderPtr->nextPtr;
}
if (borderPtr->objRefCount == 0) {
ckfree((char *) borderPtr);
}
}
void DBus_Disconnect(Tcl_Interp *interp, Tcl_HashEntry *busPtr)
{
Tcl_DBusBus *data;
Tcl_HashEntry *hPtr;
Tcl_DBusMonitorData *snoop;
data = Tcl_GetHashValue(busPtr);
/* Find all paths with handlers registered by the interp */
DBus_InterpCleanup(interp, data->conn, "/");
/* Find all handlers of the interp without a path */
if (data->fallback != NULL) {
if (DBus_HandlerCleanup(interp, data->fallback)) {
ckfree((char *)data->fallback);
data->fallback = NULL;
}
}
/* Find snoop handlers */
hPtr = Tcl_FindHashEntry(data->snoop, (char *) interp);
if (hPtr != NULL) {
snoop = Tcl_GetHashValue(hPtr);
if (snoop != NULL) {
/* Uninstall the monitor script */
dbus_connection_remove_filter(data->conn, DBus_Monitor, snoop);
Tcl_DecrRefCount(snoop->script);
ckfree((char *) snoop);
}
Tcl_DeleteHashEntry(hPtr);
if (Tcl_CheckHashEmpty(data->snoop)) {
/* Last interpreter that was connected to the dbus */
Tcl_DeleteHashTable(data->snoop);
ckfree((char *) data->snoop);
if (data->type == N_BUS_TYPES)
dbus_connection_unref(data->conn);
ckfree((char *) data);
if (defaultbus == data) defaultbus = NULL;
Tcl_DeleteHashEntry(busPtr);
}
}
}
int mpsa_RemoveListFromHash(
char *ListName
)
{
Tcl_HashEntry *Entry;
Entry = Tcl_FindHashEntry(&mpsa_ListHashTable, ListName);
if(Entry == NULL) {
return MPSA_FAIL;
} else {
Tcl_DeleteHashEntry(Entry);
}
return MPSA_OKAY;
}
void
tn_delete (TNPtr n)
{
T* t = n->tree;
/* We assume that the node either has no parent or siblings anymore,
* or that their presence does not matter. The node may still have
* children. They are deleted recursively. That is the situation
* where the parent/sibling information does not matter anymore, and
* can be ignored.
*/
tn_notleaf (n);
tn_notnode (n);
Tcl_DecrRefCount (n->name); n->name = NULL;
Tcl_DeleteHashEntry (n->he); n->he = NULL;
if (n->child) {
int i;
for (i = 0; i < n->nchildren; i++) {
ASSERT_BOUNDS (i, n->nchildren);
tn_delete (n->child [i]);
n->child [i] = NULL;
}
ckfree ((char*) n->child);
n->child = NULL;
n->nchildren = 0;
n->maxchildren = 0;
}
if (n->attr) {
Tcl_HashSearch hs;
Tcl_HashEntry* he;
for(he = Tcl_FirstHashEntry(n->attr, &hs);
he != NULL;
he = Tcl_NextHashEntry(&hs)) {
Tcl_DecrRefCount ((Tcl_Obj*) Tcl_GetHashValue(he));
}
Tcl_DeleteHashTable(n->attr);
ckfree ((char*) n->attr);
n->attr = NULL;
}
ckfree ((char*) n);
}
void
Tk_FreeGC(
Display *display, /* Display for which gc was allocated. */
GC gc) /* Graphics context to be released. */
{
Tcl_HashEntry *idHashPtr;
register TkGC *gcPtr;
TkDisplay *dispPtr = TkGetDisplay(display);
if (!dispPtr->gcInit) {
Tcl_Panic("Tk_FreeGC called before Tk_GetGC");
}
if (dispPtr->gcInit < 0) {
/*
* The GCCleanup has been called, and remaining GCs have been freed.
* This may still get called by other things shutting down, but the
* GCs should no longer be in use.
*/
return;
}
idHashPtr = Tcl_FindHashEntry(&dispPtr->gcIdTable, (char *) gc);
if (idHashPtr == NULL) {
Tcl_Panic("Tk_FreeGC received unknown gc argument");
}
gcPtr = Tcl_GetHashValue(idHashPtr);
gcPtr->refCount--;
if (gcPtr->refCount == 0) {
Tk_FreeXId(gcPtr->display, (XID) XGContextFromGC(gcPtr->gc));
XFreeGC(gcPtr->display, gcPtr->gc);
Tcl_DeleteHashEntry(gcPtr->valueHashPtr);
Tcl_DeleteHashEntry(idHashPtr);
ckfree(gcPtr);
}
}
static void
EmbWinLostSlaveProc(
ClientData clientData, /* Pointer to record describing window item. */
Tk_Window tkwin) /* Window that was claimed away by another
* geometry manager. */
{
TkTextEmbWindowClient *client = clientData;
TkTextSegment *ewPtr = client->parent;
TkTextIndex index;
Tcl_HashEntry *hPtr;
TkTextEmbWindowClient *loop;
Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask,
EmbWinStructureProc, client);
Tcl_CancelIdleCall(EmbWinDelayedUnmap, client);
if (client->textPtr->tkwin != Tk_Parent(tkwin)) {
Tk_UnmaintainGeometry(tkwin, client->textPtr->tkwin);
} else {
Tk_UnmapWindow(tkwin);
}
hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
Tcl_DeleteHashEntry(hPtr);
client->tkwin = NULL;
ewPtr->body.ew.tkwin = NULL;
/*
* Free up the memory allocation for this client.
*/
loop = ewPtr->body.ew.clients;
if (loop == client) {
ewPtr->body.ew.clients = client->next;
} else {
while (loop->next != client) {
loop = loop->next;
}
loop->next = client->next;
}
ckfree((char *) client);
index.tree = ewPtr->body.ew.sharedTextPtr->tree;
index.linePtr = ewPtr->body.ew.linePtr;
index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index);
TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL,
index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY);
}
static duk_context *
parse_id(ClientData cdata, Tcl_Interp *interp, Tcl_Obj *const idobj, int del)
{
duk_context *ctx;
Tcl_HashEntry *hashPtr;
hashPtr = Tcl_FindHashEntry(&DUKTCL_CDATA->table, Tcl_GetString(idobj));
if (hashPtr == NULL) {
Tcl_SetObjResult(interp, Tcl_NewStringObj(ERROR_TOKEN, -1));
return NULL;
}
ctx = (duk_context *) Tcl_GetHashValue(hashPtr);
if (del) {
Tcl_DeleteHashEntry(hashPtr);
}
return ctx;
}
int DBus_MethodCleanup(Tcl_Interp *interp, Tcl_HashTable *members)
{
Tcl_HashEntry *memberPtr;
Tcl_HashSearch search;
Tcl_DBusMethodData *method;
for (memberPtr = Tcl_FirstHashEntry(members, &search);
memberPtr != NULL; memberPtr = Tcl_NextHashEntry(&search)) {
method = Tcl_GetHashValue(memberPtr);
if (method->interp == interp) {
Tcl_DecrRefCount(method->script);
ckfree((char *) method);
Tcl_DeleteHashEntry(memberPtr);
}
}
return Tcl_CheckHashEmpty(members);
}
static void
SlaveStructureProc(
ClientData clientData, /* Pointer to Slave structure for window
* referred to by eventPtr. */
XEvent *eventPtr) /* Describes what just happened. */
{
register Slave *slavePtr = clientData;
TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr;
if (eventPtr->type == DestroyNotify) {
if (slavePtr->masterPtr != NULL) {
UnlinkSlave(slavePtr);
}
Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable,
(char *) slavePtr->tkwin));
FreeSlave(slavePtr);
}
}
/* Delete any receiver_reports this member has reported from the hash tables for
every sender. */
void Clear_Member_RRs(_RTP_CONTEXT *the_context, member *the_member)
{
struct link *cur_link;
Tcl_HashTable *the_table;
Tcl_HashEntry *the_entry;
cur_link = the_context->RTP_SenderList.actual_list.first_link;
while (cur_link != NULL) {
the_table = &cur_link->my_member->RR_Hash;
the_entry = Tcl_FindHashEntry(the_table, (char *) the_member->unique_id);
if (the_entry != NULL) {
free(Tcl_GetHashValue(the_entry));
Tcl_DeleteHashEntry(the_entry);
}
cur_link = cur_link->next_link;
}
}
int
TnmAttrSet(Tcl_HashTable *tablePtr, Tcl_Interp *interp, char *name, char *value)
{
Tcl_HashEntry *entryPtr;
int isNew;
char *p;
entryPtr = Tcl_FindHashEntry(tablePtr, name);
if (value) {
/*
* Check the character set of the name to make sure that
* we do not run into quoting hell problems just because
* people put funny characters into the names.
*/
for (p = name; *p; p++) {
if (!isalnum(*p) && *p != ':') {
Tcl_SetResult(interp, "illegal character in attribute name",
TCL_STATIC);
return TCL_ERROR;
}
}
if (! entryPtr) {
entryPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew);
} else {
ckfree((char *) Tcl_GetHashValue(entryPtr));
}
if (*value) {
Tcl_SetHashValue(entryPtr, ckstrdup(value));
} else {
Tcl_DeleteHashEntry(entryPtr);
entryPtr = NULL;
}
}
if (entryPtr) {
Tcl_SetResult(interp, (char *) Tcl_GetHashValue(entryPtr), TCL_STATIC);
}
return TCL_OK;
}
/* ARGSUSED */
static void
PlaceLostSlaveProc(
ClientData clientData, /* Slave structure for slave window that was
* stolen away. */
Tk_Window tkwin) /* Tk's handle for the slave window. */
{
register Slave *slavePtr = clientData;
TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr;
if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
}
Tk_UnmapWindow(tkwin);
UnlinkSlave(slavePtr);
Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable,
(char *) tkwin));
Tk_DeleteEventHandler(tkwin, StructureNotifyMask, SlaveStructureProc,
slavePtr);
FreeSlave(slavePtr);
}
void
Tk_FreeImage(
Tk_Image image) /* Token for image that is no longer needed by
* a widget. */
{
Image *imagePtr = (Image *) image;
ImageMaster *masterPtr = imagePtr->masterPtr;
Image *prevPtr;
/*
* Clean up the particular instance.
*/
if (masterPtr->typePtr != NULL) {
masterPtr->typePtr->freeProc(imagePtr->instanceData,
imagePtr->display);
}
prevPtr = masterPtr->instancePtr;
if (prevPtr == imagePtr) {
masterPtr->instancePtr = imagePtr->nextPtr;
} else {
while (prevPtr->nextPtr != imagePtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = imagePtr->nextPtr;
}
ckfree(imagePtr);
/*
* If there are no more instances left for the master, and if the master
* image has been deleted, then delete the master too.
*/
if ((masterPtr->typePtr == NULL) && (masterPtr->instancePtr == NULL)) {
if (masterPtr->hPtr != NULL) {
Tcl_DeleteHashEntry(masterPtr->hPtr);
}
Tcl_Release(masterPtr->winPtr);
ckfree(masterPtr);
}
}
int HTAssocList_delete_tcl(ClientData clientData, Tcl_Interp *interp,
int argc, char **argv) {
if (argc == 2) {
char *keyname = argv[1];
if (keyname) {
Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&HTableAssoc, keyname);
if (entryPtr) {
HTAssocList *list = Tcl_GetHashValue(entryPtr);
HTAssocList_delete(list);
Tcl_DeleteHashEntry(entryPtr);
return TCL_OK;
}
}
Tcl_AppendResult(interp, bad_vars, NULL);
return TCL_ERROR;
}
else {
Tcl_AppendResult(interp, err_string, argv[0], " associated-list", NULL);
return TCL_ERROR;
}
}