int UserMessages::GetMessageIndex(const char *msg)
{
int msgid;
if (!sm_trie_retrieve(m_Names, msg, reinterpret_cast<void **>(&msgid)))
{
if (m_FallbackSearch)
{
char msgbuf[64];
int size;
msgid = 0;
while (gamedll->GetUserMessageInfo(msgid, msgbuf, sizeof(msgbuf), size))
{
if (strcmp(msgbuf, msg) == 0)
{
sm_trie_insert(m_Names, msg, reinterpret_cast<void *>(msgid));
return msgid;
}
msgid++;
}
}
msgid = g_SMAPI->FindUserMessage(msg);
if (msgid != INVALID_MESSAGE_ID)
{
sm_trie_insert(m_Names, msg, reinterpret_cast<void *>(msgid));
}
}
return msgid;
}
DataTableInfo *CHalfLife2::_FindServerClass(const char *classname)
{
DataTableInfo *pInfo = NULL;
if (!sm_trie_retrieve(m_pClasses, classname, (void **)&pInfo))
{
ServerClass *sc = gamedll->GetAllServerClasses();
while (sc)
{
if (strcmp(classname, sc->GetName()) == 0)
{
pInfo = new DataTableInfo;
pInfo->sc = sc;
sm_trie_insert(m_pClasses, classname, pInfo);
m_Tables.push_back(pInfo);
break;
}
sc = sc->m_pNext;
}
if (!pInfo)
{
return NULL;
}
}
return pInfo;
}
void AdminCache::AddGroupCommandOverride(GroupId id, const char *name, OverrideType type, OverrideRule rule)
{
AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);
if (!pGroup || pGroup->magic != GRP_MAGIC_SET)
{
return;
}
Trie *pTrie = NULL;
if (type == Override_Command)
{
if (pGroup->pCmdTable == NULL)
{
pGroup->pCmdTable = sm_trie_create();
}
pTrie = pGroup->pCmdTable;
} else if (type == Override_CommandGroup) {
if (pGroup->pCmdGrpTable == NULL)
{
pGroup->pCmdGrpTable = sm_trie_create();
}
pTrie = pGroup->pCmdGrpTable;
} else {
return;
}
sm_trie_insert(pTrie, name, (void *)(int)rule);
}
GroupId AdminCache::AddGroup(const char *group_name)
{
if (sm_trie_retrieve(m_pGroups, group_name, NULL))
{
return INVALID_GROUP_ID;
}
GroupId id;
AdminGroup *pGroup;
if (m_FreeGroupList != INVALID_GROUP_ID)
{
pGroup = (AdminGroup *)m_pMemory->GetAddress(m_FreeGroupList);
assert(pGroup->magic == GRP_MAGIC_UNSET);
id = m_FreeGroupList;
m_FreeGroupList = pGroup->next_grp;
} else {
id = m_pMemory->CreateMem(sizeof(AdminGroup), (void **)&pGroup);
}
pGroup->immunity_level = 0;
pGroup->immune_table = -1;
pGroup->magic = GRP_MAGIC_SET;
pGroup->next_grp = INVALID_GROUP_ID;
pGroup->pCmdGrpTable = NULL;
pGroup->pCmdTable = NULL;
pGroup->addflags = 0;
if (m_FirstGroup == INVALID_GROUP_ID)
{
m_FirstGroup = id;
m_LastGroup = id;
pGroup->prev_grp = INVALID_GROUP_ID;
} else {
AdminGroup *pPrev = (AdminGroup *)m_pMemory->GetAddress(m_LastGroup);
assert(pPrev->magic == GRP_MAGIC_SET);
pPrev->next_grp = id;
pGroup->prev_grp = m_LastGroup;
m_LastGroup = id;
}
int nameidx = m_pStrings->AddString(group_name);
pGroup = (AdminGroup *)m_pMemory->GetAddress(id);
pGroup->nameidx = nameidx;
sm_trie_insert(m_pGroups, group_name, (void *)id);
return id;
}
void AdminCache::AddCommandOverride(const char *cmd, OverrideType type, FlagBits flags)
{
Trie *pTrie = NULL;
if (type == Override_Command)
{
pTrie = m_pCmdOverrides;
} else if (type == Override_CommandGroup) {
pTrie = m_pCmdGrpOverrides;
} else {
return;
}
sm_trie_insert(pTrie, cmd, (void *)(unsigned int)flags);
g_ConCmds.UpdateAdminCmdFlags(cmd, type, flags, false);
}
void AdminCache::RegisterAuthIdentType(const char *name)
{
if (sm_trie_retrieve(m_pAuthTables, name, NULL))
{
return;
}
Trie *pAuth = sm_trie_create();
AuthMethod method;
method.name.assign(name);
method.table = pAuth;
m_AuthMethods.push_back(method);
sm_trie_insert(m_pAuthTables, name, pAuth);
}
typedescription_t *CHalfLife2::FindInDataMap(datamap_t *pMap, const char *offset)
{
typedescription_t *td = NULL;
DataMapTrie &val = m_Maps[pMap];
if (!val.trie)
{
val.trie = sm_trie_create();
}
if (!sm_trie_retrieve(val.trie, offset, (void **)&td))
{
if ((td = UTIL_FindInDataMap(pMap, offset)) != NULL)
{
sm_trie_insert(val.trie, offset, td);
}
}
return td;
}
bool Translator::AddLanguage(const char *langcode, const char *description)
{
if (sm_trie_retrieve(m_pLCodeLookup, langcode, NULL))
{
return false;
}
Language *pLanguage = new Language;
unsigned int idx = m_Languages.size();
UTIL_Format(pLanguage->m_code2, sizeof(pLanguage->m_code2), "%s", langcode);
pLanguage->m_FullName = m_pStringTab->AddString(description);
sm_trie_insert(m_pLCodeLookup, langcode, reinterpret_cast<void *>(idx));
m_Languages.push_back(pLanguage);
return true;
}
bool RootConsoleMenu::AddRootConsoleCommand(const char *cmd, const char *text, IRootConsoleCommand *pHandler)
{
if (sm_trie_retrieve(m_pCommands, cmd, NULL))
{
return false;
}
sm_trie_insert(m_pCommands, cmd, pHandler);
/* Sort this into the menu */
List<ConsoleEntry *>::iterator iter = m_Menu.begin();
ConsoleEntry *pEntry;
bool inserted = false;
while (iter != m_Menu.end())
{
pEntry = (*iter);
if (strcmp(cmd, pEntry->command.c_str()) < 0)
{
ConsoleEntry *pNew = new ConsoleEntry;
pNew->command.assign(cmd);
pNew->description.assign(text);
m_Menu.insert(iter, pNew);
inserted = true;
break;
}
iter++;
}
if (!inserted)
{
ConsoleEntry *pNew = new ConsoleEntry;
pNew->command.assign(cmd);
pNew->description.assign(text);
m_Menu.push_back(pNew);
}
return true;
}
bool AdminCache::BindAdminIdentity(AdminId id, const char *auth, const char *ident)
{
if (ident[0] == '\0')
{
return false;
}
AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);
if (!pUser || pUser->magic != USR_MAGIC_SET)
{
return false;
}
Trie *pTable;
if (!sm_trie_retrieve(m_pAuthTables, auth, (void **)&pTable))
{
return false;
}
/* If the id was a steam id strip off the STEAM_*: part */
if (strcmp(auth, "steam") == 0 && strncmp(ident, "STEAM_", 6) == 0)
{
ident += 8;
}
if (sm_trie_retrieve(pTable, ident, NULL))
{
return false;
}
int i_ident = m_pStrings->AddString(ident);
pUser = (AdminUser *)m_pMemory->GetAddress(id);
pUser->auth.identidx = i_ident;
GetMethodIndex(auth, &pUser->auth.index);
return sm_trie_insert(pTable, ident, (void **)id);
}
EventHookError EventManager::HookEvent(const char *name, IPluginFunction *pFunction, EventHookMode mode)
{
EventHook *pHook;
/* If we aren't listening to this event... */
if (!gameevents->FindListener(this, name))
{
/* Then add ourselves */
if (!gameevents->AddListener(this, name, true))
{
/* If event doesn't exist... */
return EventHookErr_InvalidEvent;
}
}
/* If a hook structure does not exist... */
if (!sm_trie_retrieve(m_EventHooks, name, (void **)&pHook))
{
EventHookList *pHookList;
IPlugin *plugin = g_PluginSys.GetPluginByCtx(pFunction->GetParentContext()->GetContext());
/* Check plugin for an existing EventHook list */
if (!plugin->GetProperty("EventHooks", (void **)&pHookList))
{
pHookList = new EventHookList();
plugin->SetProperty("EventHooks", pHookList);
}
/* Create new GameEventHook structure */
pHook = new EventHook();
if (mode == EventHookMode_Pre)
{
/* Create forward for a pre hook */
pHook->pPreHook = g_Forwards.CreateForwardEx(NULL, ET_Hook, 3, GAMEEVENT_PARAMS);
/* Add to forward list */
pHook->pPreHook->AddFunction(pFunction);
} else {
/* Create forward for a post hook */
pHook->pPostHook = g_Forwards.CreateForwardEx(NULL, ET_Ignore, 3, GAMEEVENT_PARAMS);
/* Should we copy data from a pre hook to the post hook? */
pHook->postCopy = (mode == EventHookMode_Post);
/* Add to forward list */
pHook->pPostHook->AddFunction(pFunction);
}
/* Increase reference count */
pHook->refCount++;
/* Add hook structure to hook lists */
pHookList->push_back(pHook);
sm_trie_insert(m_EventHooks, name, pHook);
return EventHookErr_Okay;
}
/* Hook structure already exists at this point */
if (mode == EventHookMode_Pre)
{
/* Create pre hook forward if necessary */
if (!pHook->pPreHook)
{
pHook->pPreHook = g_Forwards.CreateForwardEx(NULL, ET_Event, 3, GAMEEVENT_PARAMS);
}
/* Add plugin function to forward list */
pHook->pPreHook->AddFunction(pFunction);
} else {
/* Create post hook forward if necessary */
if (!pHook->pPostHook)
{
pHook->pPostHook = g_Forwards.CreateForwardEx(NULL, ET_Ignore, 3, GAMEEVENT_PARAMS);
}
/* If postCopy is false, then we may want to set it to true */
if (!pHook->postCopy)
{
pHook->postCopy = (mode == EventHookMode_Post);
}
/* Add plugin function to forward list */
pHook->pPostHook->AddFunction(pFunction);
}
/* Increase reference count */
pHook->refCount++;
return EventHookErr_Okay;
}
void AdminCache::NameFlag(const char *str, AdminFlag flag)
{
sm_trie_insert(m_pLevelNames, str, (void *)flag);
}
SMCResult CPhraseFile::ReadSMC_NewSection(const SMCStates *states, const char *name)
{
bool recognized = false;
if (m_ParseState == PPS_None)
{
if (strcmp(name, "Phrases") == 0)
{
m_ParseState = PPS_Phrases;
recognized = true;
}
}
else if (m_ParseState == PPS_Phrases)
{
m_ParseState = PPS_InPhrase;
recognized = true;
void *value;
if (sm_trie_retrieve(m_pPhraseLookup, name, &value))
{
m_CurPhrase = reinterpret_cast<int>(value);
}
else
{
phrase_t *pPhrase;
m_CurPhrase = m_pMemory->CreateMem(sizeof(phrase_t), (void **)&pPhrase);
sm_trie_insert(m_pPhraseLookup, name, reinterpret_cast<void *>(m_CurPhrase));
/* Initialize new phrase */
trans_t *pTrans;
pPhrase->fmt_count = 0;
pPhrase->fmt_list = -1;
int trans_tbl = m_pMemory->CreateMem(sizeof(trans_t) * m_LangCount, (void **)&pTrans);
pPhrase = (phrase_t *)m_pMemory->GetAddress(m_CurPhrase);
pPhrase->trans_tbl = trans_tbl;
pPhrase->translations = 0;
pPhrase->fmt_bytes = 0;
for (unsigned int i=0; i<m_LangCount; i++)
{
pTrans[i].stridx = -1;
}
}
m_LastPhraseString.assign(name);
}
else if (m_ParseState == PPS_InPhrase)
{
ParseError("Phrase sections may not have sub-sections");
return SMCResult_HaltFail;
}
if (!recognized)
{
ParseWarning("Ignoring invalid section \"%s\" on line %d.", name, states->line);
}
return SMCResult_Continue;
}
HandleType_t HandleSystem::CreateType(const char *name,
IHandleTypeDispatch *dispatch,
HandleType_t parent,
const TypeAccess *typeAccess,
const HandleAccess *hndlAccess,
IdentityToken_t *ident,
HandleError *err)
{
if (!dispatch)
{
if (err)
{
*err = HandleError_Parameter;
}
return 0;
}
if (typeAccess && typeAccess->hsVersion > SMINTERFACE_HANDLESYSTEM_VERSION)
{
if (err)
{
*err = HandleError_Version;
}
return 0;
}
if (hndlAccess && hndlAccess->hsVersion > SMINTERFACE_HANDLESYSTEM_VERSION)
{
if (err)
{
*err = HandleError_Version;
}
return 0;
}
bool isChild = false;
if (parent != 0)
{
isChild = true;
if (parent & HANDLESYS_SUBTYPE_MASK)
{
if (err)
{
*err = HandleError_NoInherit;
}
return 0;
}
if (parent >= HANDLESYS_TYPEARRAY_SIZE
|| m_Types[parent].dispatch == NULL)
{
if (err)
{
*err = HandleError_Parameter;
}
return 0;
}
if (m_Types[parent].typeSec.access[HTypeAccess_Inherit] == false
&& (m_Types[parent].typeSec.ident != ident))
{
if (err)
{
*err = HandleError_Access;
}
return 0;
}
}
if (name && name[0] != '\0')
{
if (sm_trie_retrieve(m_TypeLookup, name, NULL))
{
if (err)
{
*err = HandleError_Parameter;
}
return 0;
}
}
unsigned int index;
if (isChild)
{
QHandleType *pParent = &m_Types[parent];
if (pParent->children >= HANDLESYS_MAX_SUBTYPES)
{
if (err)
{
*err = HandleError_Limit;
}
return 0;
}
index = 0;
for (unsigned int i=1; i<=HANDLESYS_MAX_SUBTYPES; i++)
{
if (m_Types[parent + i].dispatch == NULL)
{
index = parent + i;
break;
}
}
if (!index)
{
if (err)
{
*err = HandleError_Limit;
}
return 0;
}
pParent->children++;
} else {
if (m_FreeTypes == 0)
{
/* Reserve another index */
if (m_TypeTail >= HANDLESYS_TYPEARRAY_SIZE)
{
if (err)
{
*err = HandleError_Limit;
}
return 0;
} else {
m_TypeTail += (HANDLESYS_MAX_SUBTYPES + 1);
index = m_TypeTail;
}
} else {
/* The "free array" is compacted into the normal array for easiness */
index = m_Types[m_FreeTypes--].freeID;
}
}
QHandleType *pType = &m_Types[index];
pType->dispatch = dispatch;
if (name && name[0] != '\0')
{
pType->nameIdx = m_strtab->AddString(name);
sm_trie_insert(m_TypeLookup, name, (void *)pType);
} else {
pType->nameIdx = -1;
}
pType->opened = 0;
if (typeAccess)
{
pType->typeSec = *typeAccess;
} else {
InitAccessDefaults(&pType->typeSec, NULL);
pType->typeSec.ident = ident;
}
if (hndlAccess)
{
pType->hndlSec = *hndlAccess;
} else {
InitAccessDefaults(NULL, &pType->hndlSec);
}
if (!isChild)
{
pType->children = 0;
}
return index;
}
