bool RootConsoleMenu::RemoveRootConsoleCommand(const char *cmd, IRootConsoleCommand *pHandler)
{
/* Sanity tests */
IRootConsoleCommand *object;
if (sm_trie_retrieve(m_pCommands, cmd, (void **)&object))
{
if (object != pHandler)
{
return false;
}
} else {
return false;
}
sm_trie_delete(m_pCommands, cmd);
List<ConsoleEntry *>::iterator iter;
ConsoleEntry *pEntry;
for (iter=m_Menu.begin(); iter!=m_Menu.end(); iter++)
{
pEntry = (*iter);
if (pEntry->command.compare(cmd) == 0)
{
delete pEntry;
m_Menu.erase(iter);
break;
}
}
return true;
}
void CPhraseFile::ReadSMC_ParseEnd(bool halted, bool failed)
{
/* Check to see if we have any dangling phrases that weren't completed, and scrap them */
if ((halted || failed) && m_LastPhraseString.size())
{
sm_trie_delete(m_pPhraseLookup, m_LastPhraseString.c_str());
}
}
bool AdminCache::InvalidateAdmin(AdminId id)
{
AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);
AdminUser *pOther;
if (!pUser || pUser->magic != USR_MAGIC_SET)
{
return false;
}
if (!m_InvalidatingAdmins && !m_destroying)
{
g_Players.ClearAdminId(id);
}
/* Unlink from the dbl link list */
if (id == m_FirstUser && id == m_LastUser)
{
m_FirstUser = INVALID_ADMIN_ID;
m_LastUser = INVALID_ADMIN_ID;
} else if (id == m_FirstUser) {
m_FirstUser = pUser->next_user;
pOther = (AdminUser *)m_pMemory->GetAddress(m_FirstUser);
pOther->prev_user = INVALID_ADMIN_ID;
} else if (id == m_LastUser) {
m_LastUser = pUser->prev_user;
pOther = (AdminUser *)m_pMemory->GetAddress(m_LastUser);
pOther->next_user = INVALID_ADMIN_ID;
} else {
pOther = (AdminUser *)m_pMemory->GetAddress(pUser->prev_user);
pOther->next_user = pUser->next_user;
pOther = (AdminUser *)m_pMemory->GetAddress(pUser->next_user);
pOther->prev_user = pUser->prev_user;
}
/* Unlink from auth tables */
if (pUser->auth.identidx != -1)
{
Trie *pTrie = GetMethodByIndex(pUser->auth.index);
if (pTrie)
{
sm_trie_delete(pTrie, m_pStrings->GetString(pUser->auth.identidx));
}
}
/* Clear table counts */
pUser->grp_count = 0;
/* Link into free list */
pUser->magic = USR_MAGIC_UNSET;
pUser->next_user = m_FreeUserList;
m_FreeUserList = id;
/* Unset serial change */
pUser->serialchange = 0;
return true;
}
void AdminCache::_UnsetCommandOverride(const char *cmd)
{
if (!m_pCmdOverrides)
{
return;
}
sm_trie_delete(m_pCmdOverrides, cmd);
g_ConCmds.UpdateAdminCmdFlags(cmd, Override_Command, 0, true);
}
void AdminCache::_UnsetCommandGroupOverride(const char *group)
{
if (!m_pCmdGrpOverrides)
{
return;
}
sm_trie_delete(m_pCmdGrpOverrides, group);
g_ConCmds.UpdateAdminCmdFlags(group, Override_CommandGroup, 0, true);
}
SMCResult CPhraseFile::ReadSMC_LeavingSection(const SMCStates *states)
{
if (m_ParseState == PPS_InPhrase)
{
if (m_CurPhrase == -1 && m_LastPhraseString.size())
{
sm_trie_delete(m_pPhraseLookup, m_LastPhraseString.c_str());
}
m_CurPhrase = -1;
m_ParseState = PPS_Phrases;
m_LastPhraseString.assign("");
}
else if (m_ParseState == PPS_Phrases)
{
m_ParseState = PPS_None;
}
return SMCResult_Continue;
}
EventHookError EventManager::UnhookEvent(const char *name, IPluginFunction *pFunction, EventHookMode mode)
{
EventHook *pHook;
IChangeableForward **pEventForward;
/* If hook does not exist at all */
if (!sm_trie_retrieve(m_EventHooks, name, (void **)&pHook))
{
return EventHookErr_NotActive;
}
/* One forward to rule them all */
if (mode == EventHookMode_Pre)
{
pEventForward = &pHook->pPreHook;
} else {
pEventForward = &pHook->pPostHook;
}
/* Remove function from forward's list */
if (*pEventForward == NULL || !(*pEventForward)->RemoveFunction(pFunction))
{
return EventHookErr_InvalidCallback;
}
/* If forward's list contains 0 functions now, free it */
if ((*pEventForward)->GetFunctionCount() == 0)
{
g_Forwards.ReleaseForward(*pEventForward);
*pEventForward = NULL;
}
/* Decrement reference count */
if (--pHook->refCount == 0)
{
/* If reference count is now 0, free hook structure */
EventHookList *pHookList;
IPlugin *plugin = g_PluginSys.GetPluginByCtx(pFunction->GetParentContext()->GetContext());
/* Get plugin's event hook list */
if (!plugin->GetProperty("EventHooks", (void**)&pHookList))
{
return EventHookErr_NotActive;
}
/* Make sure the event was actually being hooked */
if (pHookList->find(pHook) == pHookList->end())
{
return EventHookErr_NotActive;
}
/* Remove current structure from plugin's list */
pHookList->remove(pHook);
/* Delete entry in trie */
sm_trie_delete(m_EventHooks, name);
/* And finally free structure memory */
delete pHook;
}
return EventHookErr_Okay;
}
void AdminCache::InvalidateGroup(GroupId id)
{
AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);
AdminGroup *pOther;
if (!pGroup || pGroup->magic != GRP_MAGIC_SET)
{
return;
}
const char *str = m_pStrings->GetString(pGroup->nameidx);
sm_trie_delete(m_pGroups, str);
/* Unlink from the live dbllink list */
if (id == m_FirstGroup && id == m_LastGroup)
{
m_LastGroup = INVALID_GROUP_ID;
m_FirstGroup = INVALID_GROUP_ID;
} else if (id == m_FirstGroup) {
m_FirstGroup = pGroup->next_grp;
pOther = (AdminGroup *)m_pMemory->GetAddress(m_FirstGroup);
pOther->prev_grp = INVALID_GROUP_ID;
} else if (id == m_LastGroup) {
m_LastGroup = pGroup->prev_grp;
pOther = (AdminGroup *)m_pMemory->GetAddress(m_LastGroup);
pOther->next_grp = INVALID_GROUP_ID;
} else {
pOther = (AdminGroup *)m_pMemory->GetAddress(pGroup->prev_grp);
pOther->next_grp = pGroup->next_grp;
pOther = (AdminGroup *)m_pMemory->GetAddress(pGroup->next_grp);
pOther->prev_grp = pGroup->prev_grp;
}
/* Free any used memory to be safe */
if (pGroup->pCmdGrpTable)
{
sm_trie_destroy(pGroup->pCmdGrpTable);
pGroup->pCmdGrpTable = NULL;
}
if (pGroup->pCmdTable)
{
sm_trie_destroy(pGroup->pCmdTable);
pGroup->pCmdTable = NULL;
}
/* Link into the free list */
pGroup->magic = GRP_MAGIC_UNSET;
pGroup->next_grp = m_FreeGroupList;
m_FreeGroupList = id;
int idx = m_FirstUser;
AdminUser *pUser;
int *table;
while (idx != INVALID_ADMIN_ID)
{
pUser = (AdminUser *)m_pMemory->GetAddress(idx);
if (pUser->grp_count > 0)
{
table = (int *)m_pMemory->GetAddress(pUser->grp_table);
for (unsigned int i=0; i<pUser->grp_count; i++)
{
if (table[i] == id)
{
/* We have to remove this entry */
for (unsigned int j=i+1; j<pUser->grp_count; j++)
{
/* Move everything down by one */
table[j-1] = table[j];
}
/* Decrease count */
pUser->grp_count--;
/* Recalculate effective flags */
pUser->eflags = pUser->flags;
for (unsigned int j=0; j<pUser->grp_count; j++)
{
pOther = (AdminGroup *)m_pMemory->GetAddress(table[j]);
pUser->eflags |= pOther->addflags;
}
/* Mark as changed */
pUser->serialchange++;
/* Break now, duplicates aren't allowed */
break;
}
}
}
idx = pUser->next_user;
}
}
bool HandleSystem::RemoveType(HandleType_t type, IdentityToken_t *ident)
{
if (type == 0 || type >= HANDLESYS_TYPEARRAY_SIZE)
{
return false;
}
QHandleType *pType = &m_Types[type];
if (pType->typeSec.ident
&& pType->typeSec.ident != ident)
{
return false;
}
if (pType->dispatch == NULL)
{
return false;
}
/* Remove children if we have to */
if (!(type & HANDLESYS_SUBTYPE_MASK))
{
QHandleType *childType;
for (unsigned int i=1; i<=HANDLESYS_MAX_SUBTYPES; i++)
{
childType = &m_Types[type + i];
if (childType->dispatch)
{
RemoveType(type + i, childType->typeSec.ident);
}
}
/* Link us into the free chain */
m_Types[++m_FreeTypes].freeID = type;
}
/* Invalidate the type now */
IHandleTypeDispatch *dispatch = pType->dispatch;
pType->dispatch = NULL;
/* Make sure nothing is using this type. */
if (pType->opened)
{
QHandle *pHandle;
for (unsigned int i=1; i<=m_HandleTail; i++)
{
pHandle = &m_Handles[i];
if (!pHandle->set || pHandle->type != type)
{
continue;
}
if (pHandle->clone)
{
/* Get parent */
QHandle *pOther = &m_Handles[pHandle->clone];
if (--pOther->refcount == 0)
{
/* Free! */
dispatch->OnHandleDestroy(type, pOther->object);
ReleasePrimHandle(pHandle->clone);
}
/* Unlink ourselves since we don't have a reference count */
ReleasePrimHandle(i);
} else {
/* If it's not a clone, we still have to check the reference count.
* Either way, we'll be destroyed eventually because the handle types do not change.
*/
if (--pHandle->refcount == 0)
{
/* Free! */
dispatch->OnHandleDestroy(type, pHandle->object);
ReleasePrimHandle(i);
}
}
if (pType->opened == 0)
{
break;
}
}
}
/* Remove it from the type cache. */
if (pType->nameIdx != -1)
{
const char *typeName;
typeName = m_strtab->GetString(pType->nameIdx);
sm_trie_delete(m_TypeLookup, typeName);
}
return true;
}
/* IGameEventManager2::FireEvent post hook */
bool EventManager::OnFireEvent_Post(IGameEvent *pEvent, bool bDontBroadcast)
{
EventHook *pHook;
EventInfo info;
IChangeableForward *pForward;
Handle_t hndl = 0;
/* The engine accepts NULL without crashing, so to prevent a crash in SM we ignore these */
if (!pEvent)
{
RETURN_META_VALUE(MRES_IGNORED, false);
}
pHook = m_EventStack.front();
if (pHook != NULL)
{
pForward = pHook->pPostHook;
if (pForward)
{
if (pHook->postCopy)
{
info.pEvent = m_EventCopies.front();
info.pOwner = NULL;
hndl = g_HandleSys.CreateHandle(m_EventType, &info, NULL, g_pCoreIdent, NULL);
pForward->PushCell(hndl);
} else {
pForward->PushCell(BAD_HANDLE);
}
pForward->PushString(pHook->name);
pForward->PushCell(bDontBroadcast);
pForward->Execute(NULL);
if (pHook->postCopy)
{
/* Free handle */
HandleSecurity sec(NULL, g_pCoreIdent);
g_HandleSys.FreeHandle(hndl, &sec);
/* Free event structure */
gameevents->FreeEvent(info.pEvent);
m_EventCopies.pop();
}
}
/* Decrement reference count, check if a delayed delete is needed */
if (--pHook->refCount == 0)
{
assert(pHook->pPostHook == NULL);
assert(pHook->pPreHook == NULL);
sm_trie_delete(m_EventHooks, pHook->name);
free(pHook->name);
delete pHook;
}
}
m_EventStack.pop();
RETURN_META_VALUE(MRES_IGNORED, true);
}