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; }