static void FreeTheme(Theme *themePtr)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
/*
* Free element table:
*/
entryPtr = Tcl_FirstHashEntry(&themePtr->elementTable, &search);
while (entryPtr != NULL) {
Ttk_ElementClass *elementClass = Tcl_GetHashValue(entryPtr);
FreeElementClass(elementClass);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&themePtr->elementTable);
/*
* Free style table:
*/
entryPtr = Tcl_FirstHashEntry(&themePtr->styleTable, &search);
while (entryPtr != NULL) {
Style *stylePtr = Tcl_GetHashValue(entryPtr);
FreeStyle(stylePtr);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&themePtr->styleTable);
/*
* Free theme record:
*/
ckfree(themePtr);
return;
}
static void FreeTheme(Theme *themePtr)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
/*
* Free associated ElementImpl's
*/
entryPtr = Tcl_FirstHashEntry(&themePtr->elementTable, &search);
while (entryPtr != NULL) {
ElementImpl *elementImpl = (ElementImpl *)Tcl_GetHashValue(entryPtr);
FreeElementImpl(elementImpl);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&themePtr->elementTable);
/*
* Free style table:
*/
entryPtr = Tcl_FirstHashEntry(&themePtr->styleTable, &search);
while (entryPtr != NULL) {
Style *stylePtr = (Style*)Tcl_GetHashValue(entryPtr);
FreeStyle(stylePtr);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&themePtr->styleTable);
/*
* Free theme record:
*/
ckfree((char *)themePtr);
return;
}
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;
}
static void FreeStyle(Style *stylePtr)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
entryPtr = Tcl_FirstHashEntry(&stylePtr->settingsTable, &search);
while (entryPtr != NULL) {
Ttk_StateMap stateMap = (Ttk_StateMap)Tcl_GetHashValue(entryPtr);
Tcl_DecrRefCount(stateMap);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&stylePtr->settingsTable);
entryPtr = Tcl_FirstHashEntry(&stylePtr->defaultsTable, &search);
while (entryPtr != NULL) {
Tcl_Obj *defaultValue = (Ttk_StateMap)Tcl_GetHashValue(entryPtr);
Tcl_DecrRefCount(defaultValue);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&stylePtr->defaultsTable);
Ttk_FreeLayoutTemplate(stylePtr->layoutTemplate);
ckfree((char*)stylePtr);
}
/**
* Detaches a registry database from the registry object. This does some cleanup
* for an attached registry, then detaches it. Allocated `reg_entry` objects are
* deleted here.
*
* @param [in] reg registry to detach from
* @param [out] errPtr on error, a description of the error that occurred
* @return true if success; false if failure
*/
int reg_detach(reg_registry* reg, reg_error* errPtr) {
sqlite3_stmt* stmt = NULL;
int result = 0;
char* query = "DETACH DATABASE registry";
if (!(reg->status & reg_attached)) {
reg_throw(errPtr,REG_MISUSE,"no database is attached to this registry");
return 0;
}
if (sqlite3_prepare_v2(reg->db, query, -1, &stmt, NULL) == SQLITE_OK) {
int r;
reg_entry* entry;
Tcl_HashEntry* curr;
Tcl_HashSearch search;
/* XXX: Busy waiting, consider using sqlite3_busy_handler/timeout */
do {
sqlite3_step(stmt);
r = sqlite3_reset(stmt);
switch (r) {
case SQLITE_OK:
for (curr = Tcl_FirstHashEntry(®->open_entries, &search);
curr != NULL; curr = Tcl_NextHashEntry(&search)) {
entry = Tcl_GetHashValue(curr);
if (entry->proc) {
free(entry->proc);
}
free(entry);
}
Tcl_DeleteHashTable(®->open_entries);
for (curr = Tcl_FirstHashEntry(®->open_files, &search);
curr != NULL; curr = Tcl_NextHashEntry(&search)) {
reg_file* file = Tcl_GetHashValue(curr);
free(file->proc);
free(file->key.path);
free(file);
}
Tcl_DeleteHashTable(®->open_files);
reg->status &= ~reg_attached;
result = 1;
break;
case SQLITE_BUSY:
break;
default:
reg_sqlite_error(reg->db, errPtr, query);
break;
}
} while (r == SQLITE_BUSY);
} else {
reg_sqlite_error(reg->db, errPtr, query);
}
if (stmt) {
sqlite3_finalize(stmt);
}
return result;
}
void
TclFinalizeThreadStorage(void)
{
Tcl_HashSearch search; /* We need to hit every thread with this
* search. */
Tcl_HashEntry *hPtr; /* Hash entry for current thread in master
* table. */
Tcl_MutexLock(&threadStorageLock);
/*
* We are going to delete the hash table for every thread now. This hash
* table should be empty at this point, except for one entry for the
* current thread.
*/
for (hPtr = Tcl_FirstHashEntry(&threadStorageHashTable, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
Tcl_HashTable *hashTablePtr = Tcl_GetHashValue(hPtr);
if (hashTablePtr != NULL) {
/*
* Delete thread specific hash table for the thread in question
* and free the struct.
*/
Tcl_DeleteHashTable(hashTablePtr);
TclpSysFree((char *)hashTablePtr);
}
/*
* Delete thread specific entry from master hash table.
*/
Tcl_SetHashValue(hPtr, NULL);
}
Tcl_DeleteHashTable(&threadStorageHashTable);
/*
* Clear out the thread storage cache as well.
*/
memset((void*) &threadStorageCache, 0,
sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
/*
* Reset this to zero, it will be set to STORAGE_FIRST_KEY if the thread
* storage subsystem gets reinitialized
*/
nextThreadStorageKey = STORAGE_INVALID_KEY;
Tcl_MutexUnlock(&threadStorageLock);
}
/* Ttk_StylePkgFree --
* Cleanup procedure for StylePackageData.
*/
static void Ttk_StylePkgFree(ClientData clientData, Tcl_Interp *interp)
{
StylePackageData *pkgPtr = (StylePackageData *)clientData;
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
Theme *themePtr;
Cleanup *cleanup;
/*
* Cancel any pending ThemeChanged calls:
*/
if (pkgPtr->themeChangePending) {
Tcl_CancelIdleCall(ThemeChangedProc, pkgPtr);
}
/*
* Free themes.
*/
entryPtr = Tcl_FirstHashEntry(&pkgPtr->themeTable, &search);
while (entryPtr != NULL) {
themePtr = (Theme *) Tcl_GetHashValue(entryPtr);
FreeTheme(themePtr);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&pkgPtr->themeTable);
/*
* Free element constructor table:
*/
entryPtr = Tcl_FirstHashEntry(&pkgPtr->factoryTable, &search);
while (entryPtr != NULL) {
ckfree(Tcl_GetHashValue(entryPtr));
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&pkgPtr->factoryTable);
/*
* Release cache:
*/
Ttk_FreeResourceCache(pkgPtr->cache);
/*
* Call all registered cleanup procedures:
*/
cleanup = pkgPtr->cleanupList;
while (cleanup) {
Cleanup *next = cleanup->next;
cleanup->cleanupProc(cleanup->clientData);
ckfree((ClientData)cleanup);
cleanup = next;
}
ckfree((char*)pkgPtr);
}
/*
* Syslog_Delete - Tcl_CmdDeleteProc for syslog command.
* Frees all hash tables and closes log if it was opened.
*/
static void Syslog_Delete(ClientData data)
{ SyslogInfo *info=(SyslogInfo *)data;
Tcl_DeleteHashTable(info->facilities);
Tcl_Free((char *)info->facilities);
Tcl_DeleteHashTable(info->priorities);
Tcl_Free((char *)info->priorities);
if (info->logOpened) {
closelog();
}
Tcl_Free((char *)info);
}
void
TkStylePkgFree(
TkMainInfo *mainPtr) /* The application being deleted. */
{
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
StyleEngine *enginePtr;
int i;
tsdPtr->nbInit--;
if (tsdPtr->nbInit != 0) {
return;
}
/*
* Free styles.
*/
entryPtr = Tcl_FirstHashEntry(&tsdPtr->styleTable, &search);
while (entryPtr != NULL) {
ckfree(Tcl_GetHashValue(entryPtr));
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&tsdPtr->styleTable);
/*
* Free engines.
*/
entryPtr = Tcl_FirstHashEntry(&tsdPtr->engineTable, &search);
while (entryPtr != NULL) {
enginePtr = Tcl_GetHashValue(entryPtr);
FreeStyleEngine(enginePtr);
ckfree(enginePtr);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&tsdPtr->engineTable);
/*
* Free elements.
*/
for (i = 0; i < tsdPtr->nbElements; i++) {
FreeElement(tsdPtr->elements+i);
}
Tcl_DeleteHashTable(&tsdPtr->elementTable);
ckfree(tsdPtr->elements);
}
int
ts_lua_del_shared_dict(ts_lua_shared_dict *dct)
{
ts_lua_hash_table_iterate(&dct->map.t, free_entry, NULL);
Tcl_DeleteHashTable(&dct->map.t);
return 0;
}
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
TrimUnreachable(
CompileEnv *envPtr)
{
unsigned char *currentInstPtr;
Tcl_HashTable targets;
LocateTargetAddresses(envPtr, &targets);
for (currentInstPtr = envPtr->codeStart ;
currentInstPtr < envPtr->codeNext-1 ;
currentInstPtr += AddrLength(currentInstPtr)) {
int clear = 0;
if (*currentInstPtr != INST_DONE) {
continue;
}
while (!IsTargetAddress(&targets, currentInstPtr + 1 + clear)) {
clear += AddrLength(currentInstPtr + 1 + clear);
}
if (currentInstPtr + 1 + clear == envPtr->codeNext) {
envPtr->codeNext -= clear;
} else {
while (clear --> 0) {
*(currentInstPtr + 1 + clear) = INST_NOP;
}
}
}
Tcl_DeleteHashTable(&targets);
}
////////////////////////////////////////////////////
// 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);
}
void
Nsf_PointerExit(Tcl_Interp *interp) {
nonnull_assert(interp != NULL);
NsfMutexLock(&pointerMutex);
if (--pointerTableRefCount == 0) {
if (RUNTIME_STATE(interp)->logSeverity == NSF_LOG_DEBUG) {
Tcl_HashSearch hSrch;
const Tcl_HashEntry *hPtr;
for (hPtr = Tcl_FirstHashEntry(pointerHashTablePtr, &hSrch);
hPtr != NULL;
hPtr = Tcl_NextHashEntry(&hSrch)) {
const char *key = Tcl_GetHashKey(pointerHashTablePtr, hPtr);
const void *valuePtr = Tcl_GetHashValue(hPtr);
/*
* We can't use NsfLog here any more, since the Tcl procs are
* already deleted.
*/
fprintf(stderr, "Nsf_PointerExit: we have still an entry %s with value %p\n", key, valuePtr);
}
}
Tcl_DeleteHashTable(pointerHashTablePtr);
}
/*fprintf(stderr, "Nsf_PointerExit pointerTableRefCount == %d\n", pointerTableRefCount);*/
NsfMutexUnlock(&pointerMutex);
}
/*
* ExitHandler
*
* Cleans up library on exit, frees all state structures.
*
* Arguments:
* dummy - Not used.
*
* Returns:
* None.
*/
static void
ExitHandler(
ClientData dummy
)
{
/* Init clean-up. */
Tcl_MutexLock(&initMutex);
if (kernelModule != NULL) {
FreeLibrary(kernelModule);
kernelModule = NULL;
}
getDiskFreeSpaceExPtr = NULL;
initialised = FALSE;
Tcl_MutexUnlock(&initMutex);
Tcl_MutexFinalize(&initMutex);
/* Key clean-up. */
Tcl_MutexLock(&keyMutex);
if (keyTable != NULL) {
KeyClearTable();
Tcl_DeleteHashTable(keyTable);
ckfree((char *)keyTable);
keyTable = NULL;
}
Tcl_MutexUnlock(&keyMutex);
Tcl_MutexFinalize(&keyMutex);
#ifdef TCL_MEM_DEBUG
Tcl_DumpActiveMemory("MemDump.txt");
#endif
}
/*
* FreeElementImpl --
* Release resources associated with an element implementation record.
*/
static void FreeElementImpl(ElementImpl *elementImpl)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
int i;
/*
* Free default values:
*/
for (i = 0; i < elementImpl->nResources; ++i) {
if (elementImpl->defaultValues[i]) {
Tcl_DecrRefCount(elementImpl->defaultValues[i]);
}
}
ckfree((ClientData)elementImpl->defaultValues);
/*
* Free option map cache:
*/
entryPtr = Tcl_FirstHashEntry(&elementImpl->optMapCache, &search);
while (entryPtr != NULL) {
ckfree(Tcl_GetHashValue(entryPtr));
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&elementImpl->optMapCache);
ckfree(elementImpl->elementRecord);
ckfree((ClientData)elementImpl);
}
extern void
XOTclFreeObjectData(XOTclClass* cl) {
if (cl->opt && cl->opt->objectdata) {
Tcl_DeleteHashTable(cl->opt->objectdata);
ckfree((char*)cl->opt->objectdata);
cl->opt->objectdata = 0;
}
}
int DBus_HandlerCleanup(Tcl_Interp *interp, Tcl_DBusHandlerData *data)
{
if (data->signal != NULL) {
if (DBus_SignalCleanup(interp, data->signal)) {
Tcl_DeleteHashTable(data->signal);
ckfree((char *) data->signal);
data->signal = NULL;
}
}
if (data->method != NULL) {
if (DBus_MethodCleanup(interp, data->method)) {
Tcl_DeleteHashTable(data->method);
ckfree((char *) data->method);
data->method = NULL;
}
}
return (data->signal == NULL && data->method == NULL);
}
static void
FreeUidThreadExitProc(
ClientData clientData) /* Not used. */
{
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
Tcl_DeleteHashTable(&tsdPtr->uidTable);
tsdPtr->initialized = 0;
}
static void VTICUnref(VTableInterpContext *vticP, int decr)
{
vticP->nrefs -= decr;
/* Note nrefs can be < 0, when freeing from an initial allocation */
if (vticP->nrefs <= 0) {
// TBD - free vticP->dbconns hash values (as opposed to keys)
Tcl_DeleteHashTable(&vticP->dbconns);
ckfree((char *) vticP);
}
}
/*++
FreeState
Deletes hash tables and frees state structure.
Arguments:
statePtr - Pointer to a "ExtState" structure.
Return Value:
None.
--*/
static void
FreeState(
ExtState *statePtr
)
{
if (statePtr != NULL) {
CryptCloseHandles(statePtr->cryptTable);
Tcl_DeleteHashTable(statePtr->cryptTable);
ckfree((char *)statePtr->cryptTable);
#ifndef _WINDOWS
GlCloseHandles(statePtr->glftpdTable);
Tcl_DeleteHashTable(statePtr->glftpdTable);
ckfree((char *)statePtr->glftpdTable);
#endif // !_WINDOWS
ckfree((char *)statePtr);
statePtr = NULL;
}
}
HandleNameToRepMap::~HandleNameToRepMap ()
{
// Clean up any left over objects.
Tcl_HashSearch search;
Tcl_HashEntry *pEntry = Tcl_FirstHashEntry(&m_handleMap, &search);
while (pEntry != 0) {
Tcl_HashEntry *pNext = Tcl_NextHashEntry(&search);
delete static_cast<InternalRep *>(Tcl_GetHashValue(pEntry));
pEntry = pNext;
}
Tcl_DeleteHashTable(&m_handleMap);
}
/*++
FreeState
Deletes hash tables and frees state structure.
Arguments:
state - Pointer to a "ExtState" structure.
removeCmds - Remove registered commands.
removeProc - Remove the interp deletion callback.
Return Value:
None.
--*/
static void
FreeState(
ExtState *state,
int removeCmds,
int removeProc
)
{
assert(state != NULL);
DebugPrint("FreeState: state=%p state->interp=%p removeCmds=%d removeProc=%d\n",
state, state->interp, removeCmds, removeProc);
if (removeCmds) {
int i;
for (i = 0; i < ARRAYSIZE(state->cmds); i++) {
if (state->cmds[i] == NULL) {
continue;
}
Tcl_DeleteCommandFromToken(state->interp, state->cmds[i]);
}
}
if (removeProc) {
Tcl_DontCallWhenDeleted(state->interp, InterpDeleted, (ClientData)state);
}
// Free hash tables.
CryptCloseHandles(state->cryptTable);
Tcl_DeleteHashTable(state->cryptTable);
ckfree((char *)state->cryptTable);
#ifndef _WINDOWS
GlCloseHandles(state->glftpdTable);
Tcl_DeleteHashTable(state->glftpdTable);
ckfree((char *)state->glftpdTable);
#endif
ckfree((char *)state);
}
void Ttk_DeleteTagTable(Ttk_TagTable tagTable)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
entryPtr = Tcl_FirstHashEntry(&tagTable->tags, &search);
while (entryPtr != NULL) {
DeleteTag(tagTable, Tcl_GetHashValue(entryPtr));
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&tagTable->tags);
ckfree((void*)tagTable);
}
/* Destroy the RR hash for a sender, and all its associated values. */
void Delete_RR_Hash(member *the_member)
{
Tcl_HashTable *the_table = &the_member->RR_Hash;
Tcl_HashEntry *the_entry;
Tcl_HashSearch the_search;
the_entry = Tcl_FirstHashEntry(the_table, &the_search);
while (the_entry != NULL) {
free(Tcl_GetHashValue(the_entry));
the_entry = Tcl_NextHashEntry(&the_search);
}
Tcl_DeleteHashTable(the_table);
}
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
TkDeleteAllImages(
TkMainInfo *mainPtr) /* Structure describing application that is
* going away. */
{
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
for (hPtr = Tcl_FirstHashEntry(&mainPtr->imageTable, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
EventuallyDeleteImage(Tcl_GetHashValue(hPtr), 1);
}
Tcl_DeleteHashTable(&mainPtr->imageTable);
}
void Ttk_FreeResourceCache(Ttk_ResourceCache cache)
{
Tcl_HashEntry *entryPtr;
Tcl_HashSearch search;
Ttk_ClearCache(cache);
Tcl_DeleteHashTable(&cache->colorTable);
Tcl_DeleteHashTable(&cache->fontTable);
Tcl_DeleteHashTable(&cache->imageTable);
/*
* Free named colors:
*/
entryPtr = Tcl_FirstHashEntry(&cache->namedColors, &search);
while (entryPtr != NULL) {
Tcl_Obj *colorNameObj = Tcl_GetHashValue(entryPtr);
Tcl_DecrRefCount(colorNameObj);
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&cache->namedColors);
ckfree(cache);
}
/*
*--------------------------------------------------------------
*
* Table_ClearHashTable --
* This procedure is invoked to clear a STRING_KEY hash table,
* freeing the string entries and then deleting the hash table.
* The hash table cannot be used after calling this, except to
* be freed or reinitialized.
*
* Results:
* Cached info will be lost.
*
* Side effects:
* Can cause redraw.
* See the user documentation.
*
*--------------------------------------------------------------
*/
void
Table_ClearHashTable(Tcl_HashTable *hashTblPtr)
{
Tcl_HashEntry *entryPtr;
Tcl_HashSearch search;
char *value;
for (entryPtr = Tcl_FirstHashEntry(hashTblPtr, &search);
entryPtr != NULL; entryPtr = Tcl_NextHashEntry(&search)) {
value = (char *) Tcl_GetHashValue(entryPtr);
if (value != NULL) ckfree(value);
}
Tcl_DeleteHashTable(hashTblPtr);
}
static AP_Result tcl_delete_all(AP_World *ignore)
{
Tcl_HashEntry *entry;
Tcl_HashSearch search;
for (entry = Tcl_FirstHashEntry(&tcl_interp_name_table, &search);
entry; entry = Tcl_NextHashEntry(&search)) {
Tcl_DeleteInterp(Tcl_GetHashValue(entry));
}
Tcl_DeleteHashTable(&tcl_interp_name_table);
Tcl_InitHashTable(&tcl_interp_name_table, TCL_STRING_KEYS);
return AP_SUCCESS;
}
