R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

More CCvar reversing

Browse Source 
Still work-in-progress
This commit is contained in:
Kawe Mazidjatari 2022-08-13 19:41:45 +02:00
parent b18f9148e4
commit fad1a092e4
15 changed files with 2091 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
r5dev/mathlib/swap.h
View File

@ -5,6 +5,12 @@
//===========================================================================//
#pragma once
#define LittleShort( val ) ( val )
#define LittleWord( val ) ( val )
#define LittleLong( val ) ( val )
#define LittleDWord( val ) ( val )
#define LittleQWord( val ) ( val )
template <typename T>
inline T WordSwapC(T w)
{

19
r5dev/public/icvar.h
View File

@ -1,9 +1,28 @@
#ifndef ICVAR_H
#define ICVAR_H
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class ConCommandBase;
//-----------------------------------------------------------------------------
// ConVars/ComCommands are marked as having a particular DLL identifier
//-----------------------------------------------------------------------------
typedef int CVarDLLIdentifier_t;
//-----------------------------------------------------------------------------
// ConVars/ComCommands are marked as having a particular DLL identifier
//-----------------------------------------------------------------------------
typedef int CVarDLLIdentifier_t;
abstract_class ICVarIteratorInternal
{
public:
virtual void SetFirst(void) = 0;
virtual void Next(void) = 0;
virtual bool IsValid(void) = 0;
virtual ConCommandBase* Get(void) = 0;
};
#endif // ICVAR_H

15
r5dev/tier0/basetypes.h
View File

@ -342,4 +342,17 @@ protected:
#define FORWARD_DECLARE_HANDLE(name) typedef struct name##__ *name
#define DECLARE_DERIVED_POINTER_HANDLE( _name, _basehandle ) struct _name##__ : public _basehandle##__ {}; typedef struct _name##__ *_name
#define DECLARE_ALIASED_POINTER_HANDLE( _name, _alias ) typedef struct _alias##__ *name
#define DECLARE_ALIASED_POINTER_HANDLE( _name, _alias ) typedef struct _alias##__ *name
#define ExecuteNTimes( nTimes, x ) \
{ \
static int __executeCount=0;\
if ( __executeCount < nTimes )\
{ \
++__executeCount; \
x; \
} \
}
#define ExecuteOnce( x ) ExecuteNTimes( 1, x )

2
r5dev/tier1/cmd.h
View File

@ -124,7 +124,7 @@ public:
//-----------------------------------------------------------------------------
class ConCommand : public ConCommandBase
{
friend class CCVar;
friend class CCvar;
public:
static ConCommand* Create(const char* szName, const char* szHelpString, int nFlags, FnCommandCallback_t pCallback, FnCommandCompletionCallback pCommandCompletionCallback);

261
r5dev/tier1/cvar.cpp
View File

@ -4,6 +4,7 @@
#include "tier1/IConVar.h"
#include "engine/sys_dll2.h"
#include "filesystem/filesystem.h"
#include "vstdlib/concommandhash.h"
//-----------------------------------------------------------------------------
// ENGINE |
@ -343,7 +344,7 @@ int CCvarUtilities::CountVariablesWithFlags(int flags)
ConCommandBase* var;
// Loop through cvars...
CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
while (pFactory->IsValid())
@ -369,7 +370,7 @@ int CCvarUtilities::CountVariablesWithFlags(int flags)
void CCvarUtilities::EnableDevCvars()
{
// Loop through cvars...
CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
while (pFactory->IsValid())
@ -382,6 +383,27 @@ void CCvarUtilities::EnableDevCvars()
}
}
//-----------------------------------------------------------------------------
// Purpose: Removes the FCVAR_DEVELOPMENTONLY flag from all cvars, making them accessible
//-----------------------------------------------------------------------------
void CCvarUtilities::EnableHiddenCvars()
{
// Loop through cvars...
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
while (pFactory->IsValid())
{
// remove flag from all cvars
ConCommandBase* pCommandBase = pFactory->Get();
pCommandBase->RemoveFlags(FCVAR_HIDDEN);
pFactory->Next();
}
MemAllocSingleton()->Free(pFactory);
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : void CCvar::CvarList_f
@ -439,7 +461,7 @@ void CCvarUtilities::CvarList(const CCommand& args)
CUtlRBTree< ConCommandBase* > sorted(0, 0, ConCommandBaseLessFunc);
// Loop through cvars...
CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
while (pFactory->IsValid())
@ -539,7 +561,7 @@ void CCvarUtilities::CvarHelp(const CCommand& args)
//-----------------------------------------------------------------------------
void CCvarUtilities::CvarDifferences(const CCommand& args)
{
CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
int i = 0;
@ -588,7 +610,7 @@ void CCvarUtilities::CvarFindFlags_f(const CCommand& args)
ConCommandBase* var;
// Loop through vars and print out findings
CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
CCvar::CCVarIteratorInternal* pFactory = g_pCVar->FactoryInternalIterator();
pFactory->SetFirst();
while (pFactory->IsValid())
@ -656,7 +678,7 @@ int CCvarUtilities::CvarFindFlagsCompletionCallback(const char* partial, char co
// Purpose: registers input commands.
// Input : *pszCommandName -
//-----------------------------------------------------------------------------
ConCommandBase* CCVar::RegisterConCommand(ConCommandBase* pCommandToRemove)
ConCommandBase* CCvar::RegisterConCommand(ConCommandBase* pCommandToRemove)
{
const int index = 9;
return CallVFunc<ConCommandBase*>(index, this, pCommandToRemove);
@ -666,7 +688,7 @@ ConCommandBase* CCVar::RegisterConCommand(ConCommandBase* pCommandToRemove)
// Purpose: unregisters input commands.
// Input : *pszCommandName -
//-----------------------------------------------------------------------------
ConCommandBase* CCVar::UnregisterConCommand(ConCommandBase* pCommandToRemove)
ConCommandBase* CCvar::UnregisterConCommand(ConCommandBase* pCommandToRemove)
{
const int index = 10;
return CallVFunc<ConCommandBase*>(index, this, pCommandToRemove);
@ -676,7 +698,7 @@ ConCommandBase* CCVar::UnregisterConCommand(ConCommandBase* pCommandToRemove)
// Purpose: finds base commands.
// Input : *pszCommandName -
//-----------------------------------------------------------------------------
ConCommandBase* CCVar::FindCommandBase(const char* pszCommandName)
ConCommandBase* CCvar::FindCommandBase(const char* pszCommandName)
{
const int index = 14;
return CallVFunc<ConCommandBase*>(index, this, pszCommandName);
@ -686,7 +708,7 @@ ConCommandBase* CCVar::FindCommandBase(const char* pszCommandName)
// Purpose: finds ConVars.
// Input : *pszVarName -
//-----------------------------------------------------------------------------
ConVar* CCVar::FindVar(const char* pszVarName)
ConVar* CCvar::FindVar(const char* pszVarName)
{
const int index = 16;
return CallVFunc<ConVar*>(index, this, pszVarName);
@ -696,7 +718,7 @@ ConVar* CCVar::FindVar(const char* pszVarName)
// Purpose: finds ConCommands.
// Input : *pszCommandName -
//-----------------------------------------------------------------------------
ConCommand* CCVar::FindCommand(const char* pszCommandName)
ConCommand* CCvar::FindCommand(const char* pszCommandName)
{
const int index = 18;
return CallVFunc<ConCommand*>(index, this, pszCommandName);
@ -705,7 +727,7 @@ ConCommand* CCVar::FindCommand(const char* pszCommandName)
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCVar::CallGlobalChangeCallbacks(ConVar* pConVar, const char* pOldString)
void CCvar::CallGlobalChangeCallbacks(ConVar* pConVar, const char* pOldString)
{
const int index = 23;
CallVFunc<void>(index, this, pConVar, pOldString);
@ -714,22 +736,22 @@ void CCVar::CallGlobalChangeCallbacks(ConVar* pConVar, const char* pOldString)
//-----------------------------------------------------------------------------
// Purpose: deal with queued material system ConVars
//-----------------------------------------------------------------------------
bool CCVar::IsMaterialThreadSetAllowed(void)
bool CCvar::IsMaterialThreadSetAllowed(void)
{
const int index = 35;
return CallVFunc<bool>(index, this);
}
void CCVar::QueueMaterialThreadSetValue(ConVar* pConVar, float flValue)
void CCvar::QueueMaterialThreadSetValue(ConVar* pConVar, float flValue)
{
const int index = 36;
CallVFunc<void>(index, this, pConVar, flValue);
}
void CCVar::QueueMaterialThreadSetValue(ConVar* pConVar, int nValue)
void CCvar::QueueMaterialThreadSetValue(ConVar* pConVar, int nValue)
{
const int index = 37;
CallVFunc<void>(index, this, pConVar, nValue);
}
void CCVar::QueueMaterialThreadSetValue(ConVar* pConVar, const char* pValue)
void CCvar::QueueMaterialThreadSetValue(ConVar* pConVar, const char* pValue)
{
const int index = 38;
CallVFunc<void>(index, this, pConVar, pValue);
@ -738,7 +760,7 @@ void CCVar::QueueMaterialThreadSetValue(ConVar* pConVar, const char* pValue)
//-----------------------------------------------------------------------------
// Purpose: iterates over all ConVars
//-----------------------------------------------------------------------------
CCVarIteratorInternal* CCVar::FactoryInternalIterator(void)
CCvar::CCVarIteratorInternal* CCvar::FactoryInternalIterator(void)
{
const int index = 41;
return CallVFunc<CCVarIteratorInternal*>(index, this);
@ -747,7 +769,7 @@ CCVarIteratorInternal* CCVar::FactoryInternalIterator(void)
//-----------------------------------------------------------------------------
// Purpose: returns all ConVars
//-----------------------------------------------------------------------------
unordered_map<string, ConCommandBase*> CCVar::DumpToMap(void)
unordered_map<string, ConCommandBase*> CCvar::DumpToMap(void)
{
stringstream ss;
CCVarIteratorInternal* itint = FactoryInternalIterator(); // Allocate new InternalIterator.
@ -765,4 +787,207 @@ unordered_map<string, ConCommandBase*> CCVar::DumpToMap(void)
}
///////////////////////////////////////////////////////////////////////////////
CCVar* g_pCVar = nullptr;
CCvar* g_pCVar = nullptr;
//-----------------------------------------------------------------------------
// Console command hash data structure
//-----------------------------------------------------------------------------
CConCommandHash::CConCommandHash()
{
Purge(true);
}
CConCommandHash::~CConCommandHash()
{
Purge(false);
}
void CConCommandHash::Purge(bool bReinitialize)
{
m_aBuckets.Purge();
m_aDataPool.Purge();
if (bReinitialize)
{
Init();
}
}
// Initialize.
void CConCommandHash::Init(void)
{
// kNUM_BUCKETS must be a power of two.
COMPILE_TIME_ASSERT((kNUM_BUCKETS & (kNUM_BUCKETS - 1)) == 0);
// Set the bucket size.
m_aBuckets.SetSize(kNUM_BUCKETS);
for (int iBucket = 0; iBucket < kNUM_BUCKETS; ++iBucket)
{
m_aBuckets[iBucket] = m_aDataPool.InvalidIndex();
}
// Calculate the grow size.
int nGrowSize = 4 * kNUM_BUCKETS;
m_aDataPool.SetGrowSize(nGrowSize);
}
//-----------------------------------------------------------------------------
// Purpose: Insert data into the hash table given its key (unsigned int),
// WITH a check to see if the element already exists within the hash.
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashHandle_t CConCommandHash::Insert(ConCommandBase* cmd)
{
// Check to see if that key already exists in the buckets (should be unique).
CCommandHashHandle_t hHash = Find(cmd);
if (hHash != InvalidHandle())
return hHash;
return FastInsert(cmd);
}
//-----------------------------------------------------------------------------
// Purpose: Insert data into the hash table given its key (unsigned int),
// WITHOUT a check to see if the element already exists within the hash.
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashHandle_t CConCommandHash::FastInsert(ConCommandBase* cmd)
{
// Get a new element from the pool.
intptr_t iHashData = m_aDataPool.Alloc(true);
HashEntry_t* RESTRICT pHashData = &m_aDataPool[iHashData];
if (!pHashData)
return InvalidHandle();
HashKey_t key = Hash(cmd);
// Add data to new element.
pHashData->m_uiKey = key;
pHashData->m_Data = cmd;
// Link element.
int iBucket = key & kBUCKETMASK; // HashFuncs::Hash( uiKey, m_uiBucketMask );
m_aDataPool.LinkBefore(m_aBuckets[iBucket], iHashData);
m_aBuckets[iBucket] = iHashData;
return iHashData;
}
//-----------------------------------------------------------------------------
// Purpose: Remove a given element from the hash.
//-----------------------------------------------------------------------------
void CConCommandHash::Remove(CCommandHashHandle_t hHash) RESTRICT
{
HashEntry_t* RESTRICT entry = &m_aDataPool[hHash];
HashKey_t iBucket = entry->m_uiKey & kBUCKETMASK;
if (m_aBuckets[iBucket] == hHash)
{
// It is a bucket head.
m_aBuckets[iBucket] = m_aDataPool.Next(hHash);
}
else
{
// Not a bucket head.
m_aDataPool.Unlink(hHash);
}
// Remove the element.
m_aDataPool.Remove(hHash);
}
//-----------------------------------------------------------------------------
// Purpose: Remove all elements from the hash
//-----------------------------------------------------------------------------
void CConCommandHash::RemoveAll(void)
{
m_aBuckets.RemoveAll();
m_aDataPool.RemoveAll();
}
//-----------------------------------------------------------------------------
// Find hash entry corresponding to a string name
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashHandle_t CConCommandHash::Find(const char* name, HashKey_t hashkey) const RESTRICT
{
// hash the "key" - get the correct hash table "bucket"
int iBucket = hashkey & kBUCKETMASK;
for (datapool_t::IndexLocalType_t iElement = m_aBuckets[iBucket]; iElement != m_aDataPool.InvalidIndex(); iElement = m_aDataPool.Next(iElement))
{
const HashEntry_t& element = m_aDataPool[iElement];
if (element.m_uiKey == hashkey && // if hashes of strings match,
Q_stricmp(name, element.m_Data->GetName()) == 0) // then test the actual strings
{
return iElement;
}
}
// found nuffink
return InvalidHandle();
}
//-----------------------------------------------------------------------------
// Find a command in the hash.
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashHandle_t CConCommandHash::Find(const ConCommandBase* cmd) const RESTRICT
{
// Set this #if to 1 if the assert at bottom starts whining --
// that indicates that a console command is being double-registered,
// or something similarly nonfatally bad. With this #if 1, we'll search
// by name instead of by pointer, which is more robust in the face
// of double registered commands, but obviously slower.
#if 0
return Find(cmd->GetName());
#else
HashKey_t hashkey = Hash(cmd);
int iBucket = hashkey & kBUCKETMASK;
// hunt through all entries in that bucket
for (datapool_t::IndexLocalType_t iElement = m_aBuckets[iBucket]; iElement != m_aDataPool.InvalidIndex(); iElement = m_aDataPool.Next(iElement))
{
const HashEntry_t& element = m_aDataPool[iElement];
if (element.m_uiKey == hashkey && // if the hashes match...
element.m_Data == cmd) // and the pointers...
{
// in debug, test to make sure we don't have commands under the same name
// or something goofy like that
Assert(iElement == Find(cmd->GetName()),
"ConCommand %s had two entries in the hash!", cmd->GetName());
// return this element
return iElement;
}
}
// found nothing.
#ifdef DBGFLAG_ASSERT // double check against search by name
CCommandHashHandle_t dbghand = Find(cmd->GetName());
AssertMsg1(InvalidHandle() == dbghand,
"ConCommand %s couldn't be found by pointer, but was found by name!", cmd->GetName());
#endif
return InvalidHandle();
#endif
}
//#ifdef _DEBUG
// Dump a report to MSG
void CConCommandHash::Report(void)
{
DevMsg(eDLL_T::ENGINE, "Console command hash bucket load:\n");
int total = 0;
for (int iBucket = 0; iBucket < kNUM_BUCKETS; ++iBucket)
{
int count = 0;
CCommandHashHandle_t iElement = m_aBuckets[iBucket]; // get the head of the bucket
while (iElement != m_aDataPool.InvalidIndex())
{
++count;
iElement = m_aDataPool.Next(iElement);
}
DevMsg(eDLL_T::ENGINE, "%d: %d\n", iBucket, count);
total += count;
}
DevMsg(eDLL_T::ENGINE, "\tAverage: %.1f\n", total / ((float)(kNUM_BUCKETS)));
}
//#endif

60
r5dev/tier1/cvar.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "tier1/IConVar.h"
#include <vstdlib/concommandhash.h>
//-------------------------------------------------------------------------
// ENGINE |
@ -180,6 +181,7 @@ public:
// Enable cvars marked with FCVAR_DEVELOPMENTONLY
void EnableDevCvars();
void EnableHiddenCvars();
// Lists cvars to console
void CvarList(const CCommand& args);
@ -211,16 +213,7 @@ private:
extern CCvarUtilities* cv;
class CCVarIteratorInternal // Fully reversed table, just look at the virtual function table and rename the function.
{
public:
virtual void SetFirst(void) = 0; //0
virtual void Next(void) = 0; //1
virtual bool IsValid(void) = 0; //2
virtual ConCommandBase* Get(void) = 0; //3
};
class CCVar
class CCvar
{
public:
ConCommandBase* RegisterConCommand(ConCommandBase* pCommandToAdd);
@ -236,12 +229,24 @@ public:
void QueueMaterialThreadSetValue(ConVar* pConVar, int nValue);
void QueueMaterialThreadSetValue(ConVar* pConVar, const char* pValue);
class CCVarIteratorInternal : public ICVarIteratorInternal
{
public:
virtual void SetFirst(void) = 0; //0
virtual void Next(void) = 0; //1
virtual bool IsValid(void) = 0; //2
virtual ConCommandBase* Get(void) = 0; //3
CCvar* const m_pOuter;
CConCommandHash* const m_pHash;
CConCommandHash::CCommandHashIterator_t m_hashIter;
};
CCVarIteratorInternal* FactoryInternalIterator(void);
unordered_map<string, ConCommandBase*> DumpToMap(void);
protected:
friend class CCVarIteratorInternal;
protected:
enum ConVarSetType_t
{
CONVAR_SET_STRING = 0,
@ -264,48 +269,49 @@ private:
char pad0[22]; //!TODO:
int m_nNextDLLIdentifier;
ConCommandBase* m_pConCommandList;
char m_CommandHash[208]; //!TODO:
CConCommandHash m_CommandHash;
char pad1[96];
CUtlVector< QueuedConVarSet_t > m_QueuedConVarSets;
bool m_bMaterialSystemThreadSetAllowed;
};
///////////////////////////////////////////////////////////////////////////////
extern CCVar* g_pCVar;
extern CCvar* g_pCVar;
/* ==== CCVAR =========================================================================================================================================================== */
inline CMemory p_CCVar_Disconnect;
inline auto CCVar_Disconnect = p_CCVar_Disconnect.RCast<void* (*)(void)>();
inline CMemory p_CCvar_Disconnect;
inline auto CCvar_Disconnect = p_CCvar_Disconnect.RCast<void* (*)(void)>();
inline CMemory p_CCVar_GetCommandLineValue;
inline auto CCVar_GetCommandLineValue = p_CCVar_GetCommandLineValue.RCast<const char* (*)(CCVar* thisptr, const char* pVariableName)>();
inline CMemory p_CCvar_GetCommandLineValue;
inline auto CCvar_GetCommandLineValue = p_CCvar_GetCommandLineValue.RCast<const char* (*)(CCvar* thisptr, const char* pVariableName)>();
///////////////////////////////////////////////////////////////////////////////
class VCVar : public IDetour
{
virtual void GetAdr(void) const
{
spdlog::debug("| FUN: CCVar::Disconnect : {:#18x} |\n", p_CCVar_Disconnect.GetPtr());
spdlog::debug("| FUN: CCVar::GetCommandLineValue : {:#18x} |\n", p_CCVar_GetCommandLineValue.GetPtr());
spdlog::debug("| FUN: CCvar::Disconnect : {:#18x} |\n", p_CCvar_Disconnect.GetPtr());
spdlog::debug("| FUN: CCvar::GetCommandLineValue : {:#18x} |\n", p_CCvar_GetCommandLineValue.GetPtr());
spdlog::debug("| VAR: g_pCVar : {:#18x} |\n", reinterpret_cast<uintptr_t>(g_pCVar));
spdlog::debug("+----------------------------------------------------------------+\n");
}
virtual void GetFun(void) const
{
#if defined (GAMEDLL_S0) || defined (GAMEDLL_S1)
p_CCVar_Disconnect = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x40\x57\x41\x56\x48\x83\xEC\x38\x4C\x8B\x35"), "xxxxxxxxxxx");
CCVar_Disconnect = p_CCVar_Disconnect.RCast<void* (*)(void)>(); /*40 57 41 56 48 83 EC 38 4C 8B 35 ? ? ? ?*/
p_CCvar_Disconnect = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x40\x57\x41\x56\x48\x83\xEC\x38\x4C\x8B\x35"), "xxxxxxxxxxx");
CCvar_Disconnect = p_CCvar_Disconnect.RCast<void* (*)(void)>(); /*40 57 41 56 48 83 EC 38 4C 8B 35 ? ? ? ?*/
#elif defined (GAMEDLL_S2) || defined (GAMEDLL_S3)
p_CCVar_Disconnect = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x48\x83\xEC\x28\x48\x8B\x0D\x00\x00\x00\x00\x48\x85\xC9\x74\x26\x80\x3D\x00\x00\x00\x00\x00\x74\x1D\x48\x8B\x01\x8B\x15\x00\x00\x00\x00\xFF\x50\x58\xC7\x05\x00\x00\x00\x00\x00\x00\x00\x00\xC6\x05\x00\x00\x00\x00\x00\x48\xC7\x05\x00\x00\x00"), "xxxxxxx????xxxxxxx?????xxxxxxx????xxxxx????????xx");
CCVar_Disconnect = p_CCVar_Disconnect.RCast<void* (*)(void)>(); /*48 83 EC 28 48 8B 0D ? ? ? ? 48 85 C9 74 26 80 3D ? ? ? ? ? 74 1D 48 8B 01 8B 15 ? ? ? ? FF 50 58 C7 05 ? ? ? ? ? ? ? ? C6 05 ? ? ? ? ? 48 C7 05 ? ? ? ? ? ? ? ?*/
p_CCvar_Disconnect = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x48\x83\xEC\x28\x48\x8B\x0D\x00\x00\x00\x00\x48\x85\xC9\x74\x26\x80\x3D\x00\x00\x00\x00\x00\x74\x1D\x48\x8B\x01\x8B\x15\x00\x00\x00\x00\xFF\x50\x58\xC7\x05\x00\x00\x00\x00\x00\x00\x00\x00\xC6\x05\x00\x00\x00\x00\x00\x48\xC7\x05\x00\x00\x00"), "xxxxxxx????xxxxxxx?????xxxxxxx????xxxxx????????xx");
CCvar_Disconnect = p_CCvar_Disconnect.RCast<void* (*)(void)>(); /*48 83 EC 28 48 8B 0D ? ? ? ? 48 85 C9 74 26 80 3D ? ? ? ? ? 74 1D 48 8B 01 8B 15 ? ? ? ? FF 50 58 C7 05 ? ? ? ? ? ? ? ? C6 05 ? ? ? ? ? 48 C7 05 ? ? ? ? ? ? ? ?*/
#endif
p_CCVar_GetCommandLineValue = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x40\x55\x48\x83\xEC\x20\x48\x8D\x6C\x24\x00\x48\x89\x5D\x10\x49\xC7\xC0\x00\x00\x00\x00"), "xxxxxxxxxx?xxxxxxx????");
CCVar_GetCommandLineValue = p_CCVar_GetCommandLineValue.RCast<const char* (*)(CCVar* thisptr, const char* pVariableName)>(); /*40 55 48 83 EC 20 48 8D 6C 24 ? 48 89 5D 10 49 C7 C0 ? ? ? ?*/
p_CCvar_GetCommandLineValue = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>("\x40\x55\x48\x83\xEC\x20\x48\x8D\x6C\x24\x00\x48\x89\x5D\x10\x49\xC7\xC0\x00\x00\x00\x00"), "xxxxxxxxxx?xxxxxxx????");
CCvar_GetCommandLineValue = p_CCvar_GetCommandLineValue.RCast<const char* (*)(CCvar* thisptr, const char* pVariableName)>(); /*40 55 48 83 EC 20 48 8D 6C 24 ? 48 89 5D 10 49 C7 C0 ? ? ? ?*/
}
virtual void GetVar(void) const
{
g_pCVar = g_GameDll.FindPatternSIMD(reinterpret_cast<rsig_t>(
"\x48\x83\xEC\x28\x48\x8B\x05\x00\x00\x00\x00\x48\x8D\x0D\x00\x00\x00\x00\x48\x85\xC0\x48\x89\x15"),
"xxxxxxx????xxx????xxxxxx").FindPatternSelf("48 8D 0D", CMemory::Direction::DOWN, 40).ResolveRelativeAddressSelf(0x3, 0x7).RCast<CCVar*>();
"xxxxxxx????xxx????xxxxxx").FindPatternSelf("48 8D 0D", CMemory::Direction::DOWN, 40).ResolveRelativeAddressSelf(0x3, 0x7).RCast<CCvar*>();
}
virtual void GetCon(void) const { }
virtual void Attach(void) const { }

430
r5dev/tier1/generichash.cpp Normal file
View File

@ -0,0 +1,430 @@
//======= Copyright <20> 2005, , Valve Corporation, All rights reserved. =========
//
// Purpose: Variant Pearson Hash general purpose hashing algorithm described
// by Cargill in C++ Report 1994. Generates a 16-bit result.
//
//=============================================================================
#include "core/stdafx.h"
#include "tier0/dbg.h"
#include "tier0/basetypes.h"
#include "tier0/platform.h"
#include "tier1/strtools.h"
#include "tier1/generichash.h"
#include "mathlib/swap.h"
// NOTE: This has to be the last file included!
//#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
//
// Table of randomly shuffled values from 0-255 generated by:
//
//-----------------------------------------------------------------------------
/*
void MakeRandomValues()
{
int i, j, r;
unsigned t;
srand( 0xdeadbeef );
for ( i = 0; i < 256; i++ )
{
g_nRandomValues[i] = (unsigned )i;
}
for (j = 0; j < 8; j++)
{
for (i = 0; i < 256; i++)
{
r = rand() & 0xff;
t = g_nRandomValues[i];
g_nRandomValues[i] = g_nRandomValues[r];
g_nRandomValues[r] = t;
}
}
printf("static unsigned g_nRandomValues[256] =\n{\n");
for (i = 0; i < 256; i += 16)
{
printf("\t");
for (j = 0; j < 16; j++)
printf(" %3d,", g_nRandomValues[i+j]);
printf("\n");
}
printf("};\n");
}
*/
static unsigned g_nRandomValues[256] =
{
238, 164, 191, 168, 115, 16, 142, 11, 213, 214, 57, 151, 248, 252, 26, 198,
13, 105, 102, 25, 43, 42, 227, 107, 210, 251, 86, 66, 83, 193, 126, 108,
131, 3, 64, 186, 192, 81, 37, 158, 39, 244, 14, 254, 75, 30, 2, 88,
172, 176, 255, 69, 0, 45, 116, 139, 23, 65, 183, 148, 33, 46, 203, 20,
143, 205, 60, 197, 118, 9, 171, 51, 233, 135, 220, 49, 71, 184, 82, 109,
36, 161, 169, 150, 63, 96, 173, 125, 113, 67, 224, 78, 232, 215, 35, 219,
79, 181, 41, 229, 149, 153, 111, 217, 21, 72, 120, 163, 133, 40, 122, 140,
208, 231, 211, 200, 160, 182, 104, 110, 178, 237, 15, 101, 27, 50, 24, 189,
177, 130, 187, 92, 253, 136, 100, 212, 19, 174, 70, 22, 170, 206, 162, 74,
247, 5, 47, 32, 179, 117, 132, 195, 124, 123, 245, 128, 236, 223, 12, 84,
54, 218, 146, 228, 157, 94, 106, 31, 17, 29, 194, 34, 56, 134, 239, 246,
241, 216, 127, 98, 7, 204, 154, 152, 209, 188, 48, 61, 87, 97, 225, 85,
90, 167, 155, 112, 145, 114, 141, 93, 250, 4, 201, 156, 38, 89, 226, 196,
1, 235, 44, 180, 159, 121, 119, 166, 190, 144, 10, 91, 76, 230, 221, 80,
207, 55, 58, 53, 175, 8, 6, 52, 68, 242, 18, 222, 103, 249, 147, 129,
138, 243, 28, 185, 62, 59, 240, 202, 234, 99, 77, 73, 199, 137, 95, 165,
};
//-----------------------------------------------------------------------------
// String
//-----------------------------------------------------------------------------
unsigned FASTCALL HashString(const char* pszKey)
{
const uint8* k = (const uint8*)pszKey;
unsigned even = 0,
odd = 0,
n;
while ((n = *k++) != 0)
{
even = g_nRandomValues[odd ^ n];
if ((n = *k++) != 0)
odd = g_nRandomValues[even ^ n];
else
break;
}
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// Case-insensitive string
//-----------------------------------------------------------------------------
unsigned FASTCALL HashStringCaseless(const char* pszKey)
{
const uint8* k = (const uint8*)pszKey;
unsigned even = 0,
odd = 0,
n;
while ((n = toupper(*k++)) != 0)
{
even = g_nRandomValues[odd ^ n];
if ((n = toupper(*k++)) != 0)
odd = g_nRandomValues[even ^ n];
else
break;
}
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// 32 bit conventional case-insensitive string
//-----------------------------------------------------------------------------
uint32 FASTCALL HashStringCaselessConventional(const char* pszKey)
{
uint32 hash = 0xAAAAAAAA; // Alternating 1's and 0's to maximize the effect of the later multiply and add
hash += (2 * V_strlen(pszKey)); // Add the string length * 2 to the hash to give it more variety
for (; *pszKey; pszKey++)
{
hash = ((hash << 5) + hash) + (uint8)tolower(*pszKey);
}
return hash;
}
//-----------------------------------------------------------------------------
// int hash
//-----------------------------------------------------------------------------
unsigned FASTCALL HashInt(const int n)
{
register unsigned even, odd;
odd = g_nRandomValues[(((unsigned)n >> 8) & 0xff)];
even = g_nRandomValues[odd ^ ((unsigned)n >> 24)];
odd = g_nRandomValues[even ^ ((unsigned)n >> 16) & 0xff];
even = g_nRandomValues[odd ^ ((unsigned)n >> 8) & 0xff];
odd = g_nRandomValues[even ^ ((unsigned)n & 0xff)];
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// 4-byte hash
//-----------------------------------------------------------------------------
unsigned FASTCALL Hash4(const void* pKey)
{
register const uint32* p = (const uint32*)pKey;
register unsigned even,
odd,
n;
n = *p;
odd = g_nRandomValues[((n >> 8) & 0xff)];
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// 8-byte hash
//-----------------------------------------------------------------------------
unsigned FASTCALL Hash8(const void* pKey)
{
register const uint32* p = (const uint32*)pKey;
register unsigned even,
odd,
n;
n = *p;
odd = g_nRandomValues[((n >> 8) & 0xff)];
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 1);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// 12-byte hash
//-----------------------------------------------------------------------------
unsigned FASTCALL Hash12(const void* pKey)
{
register const uint32* p = (const uint32*)pKey;
register unsigned even,
odd,
n;
n = *p;
odd = g_nRandomValues[((n >> 8) & 0xff)];
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 1);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 2);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// 16-byte hash
//-----------------------------------------------------------------------------
unsigned FASTCALL Hash16(const void* pKey)
{
register const uint32* p = (const uint32*)pKey;
register unsigned even,
odd,
n;
n = *p;
odd = g_nRandomValues[((n >> 8) & 0xff)];
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 1);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 2);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
n = *(p + 3);
even = g_nRandomValues[odd ^ (n >> 24)];
odd = g_nRandomValues[even ^ (n >> 16) & 0xff];
even = g_nRandomValues[odd ^ (n >> 8) & 0xff];
odd = g_nRandomValues[even ^ (n & 0xff)];
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// Arbitrary fixed length hash
//-----------------------------------------------------------------------------
unsigned FASTCALL HashBlock(const void* pKey, unsigned size)
{
const uint8* k = (const uint8*)pKey;
unsigned even = 0,
odd = 0,
n;
while (size)
{
--size;
n = *k++;
even = g_nRandomValues[odd ^ n];
if (size)
{
--size;
n = *k++;
odd = g_nRandomValues[even ^ n];
}
else
break;
}
return (even << 8) | odd;
}
//-----------------------------------------------------------------------------
// Murmur hash
//-----------------------------------------------------------------------------
uint32 MurmurHash2(const void* key, int len, uint32 seed)
{
// 'm' and 'r' are mixing constants generated offline.
// They're not really 'magic', they just happen to work well.
const uint32 m = 0x5bd1e995;
const int r = 24;
// Initialize the hash to a 'random' value
uint32 h = seed ^ len;
// Mix 4 bytes at a time into the hash
const unsigned char* data = (const unsigned char*)key;
while (len >= 4)
{
uint32 k = LittleDWord(*(uint32*)data);
k *= m;
k ^= k >> r;
k *= m;
h *= m;
h ^= k;
data += 4;
len -= 4;
}
// Handle the last few bytes of the input array
switch (len)
{
case 3: h ^= data[2] << 16;
case 2: h ^= data[1] << 8;
case 1: h ^= data[0];
h *= m;
};
// Do a few final mixes of the hash to ensure the last few
// bytes are well-incorporated.
h ^= h >> 13;
h *= m;
h ^= h >> 15;
return h;
}
#define TOLOWERU( c ) ( ( uint32 ) ( ( ( c >= 'A' ) && ( c <= 'Z' ) )? c + 32 : c ) )
uint32 MurmurHash2LowerCase(char const* pString, uint32 nSeed)
{
int nLen = V_strlen(pString);
char* p = (char*)stackalloc(nLen + 1);
for (int i = 0; i < nLen; i++)
{
p[i] = TOLOWERU(pString[i]);
}
return MurmurHash2(p, nLen, nSeed);
}
//-----------------------------------------------------------------------------
// Murmur hash, 64 bit- endian neutral
//-----------------------------------------------------------------------------
uint64 MurmurHash64(const void* key, int len, uint32 seed)
{
// 'm' and 'r' are mixing constants generated offline.
// They're not really 'magic', they just happen to work well.
const uint32 m = 0x5bd1e995;
const int r = 24;
// Initialize the hash to a 'random' value
uint32 h1 = seed ^ len;
uint32 h2 = 0;
// Mix 4 bytes at a time into the hash
const uint32* data = (const uint32*)key;
while (len >= 8)
{
uint32 k1 = LittleDWord(*data++);
k1 *= m; k1 ^= k1 >> r; k1 *= m;
h1 *= m; h1 ^= k1;
len -= 4;
uint32 k2 = LittleDWord(*data++);
k2 *= m; k2 ^= k2 >> r; k2 *= m;
h2 *= m; h2 ^= k2;
len -= 4;
}
if (len >= 4)
{
uint32 k1 = LittleDWord(*data++);
k1 *= m; k1 ^= k1 >> r; k1 *= m;
h1 *= m; h1 ^= k1;
len -= 4;
}
// Handle the last few bytes of the input array
switch (len)
{
case 3: h2 ^= ((uint8*)data)[2] << 16;
case 2: h2 ^= ((uint8*)data)[1] << 8;
case 1: h2 ^= ((uint8*)data)[0];
h2 *= m;
};
h1 ^= h2 >> 18; h1 *= m;
h2 ^= h1 >> 22; h2 *= m;
h1 ^= h2 >> 17; h1 *= m;
h2 ^= h1 >> 19; h2 *= m;
uint64 h = h1;
h = (h << 32) | h2;
return h;
}

1095
r5dev/tier1/utllinkedlist.h Normal file
View File

File diff suppressed because it is too large Load Diff

3
r5dev/vproj/clientsdk.vcxproj
View File

@ -111,6 +111,7 @@
<ClCompile Include="..\tier1\characterset.cpp" />
<ClCompile Include="..\tier1\cmd.cpp" />
<ClCompile Include="..\tier1\cvar.cpp" />
<ClCompile Include="..\tier1\generichash.cpp" />
<ClCompile Include="..\tier1\IConVar.cpp" />
<ClCompile Include="..\tier1\NetAdr2.cpp" />
<ClCompile Include="..\tier1\splitstring.cpp" />
@ -489,6 +490,7 @@
<ClInclude Include="..\tier1\utlblockmemory.h" />
<ClInclude Include="..\tier1\utldict.h" />
<ClInclude Include="..\tier1\utlfixedmemory.h" />
<ClInclude Include="..\tier1\utllinkedlist.h" />
<ClInclude Include="..\tier1\utlmemory.h" />
<ClInclude Include="..\tier1\utlrbtree.h" />
<ClInclude Include="..\tier1\utlvector.h" />
@ -508,6 +510,7 @@
<ClInclude Include="..\vpklib\packedstore.h" />
<ClInclude Include="..\vstdlib\callback.h" />
<ClInclude Include="..\vstdlib\completion.h" />
<ClInclude Include="..\vstdlib\concommandhash.h" />
<ClInclude Include="..\vstdlib\keyvaluessystem.h" />
<ClInclude Include="..\vstdlib\random.h" />
<ClInclude Include="..\windows\console.h" />

9
r5dev/vproj/clientsdk.vcxproj.filters
View File

@ -573,6 +573,9 @@
<ClCompile Include="..\public\utility\binstream.cpp">
<Filter>sdk\public\utility</Filter>
</ClCompile>
<ClCompile Include="..\tier1\generichash.cpp">
<Filter>sdk\tier1</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\client\cdll_engine_int.h">
@ -1703,6 +1706,12 @@
<ClInclude Include="..\tier0\annotations.h">
<Filter>sdk\tier0</Filter>
</ClInclude>
<ClInclude Include="..\tier1\utllinkedlist.h">
<Filter>sdk\tier1</Filter>
</ClInclude>
<ClInclude Include="..\vstdlib\concommandhash.h">
<Filter>sdk\vstdlib</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Image Include="..\shared\resource\lockedserver.png">

3
r5dev/vproj/dedicated.vcxproj
View File

@ -449,6 +449,7 @@
<ClInclude Include="..\tier1\utlblockmemory.h" />
<ClInclude Include="..\tier1\utldict.h" />
<ClInclude Include="..\tier1\utlfixedmemory.h" />
<ClInclude Include="..\tier1\utllinkedlist.h" />
<ClInclude Include="..\tier1\utlmemory.h" />
<ClInclude Include="..\tier1\utlrbtree.h" />
<ClInclude Include="..\tier1\utlvector.h" />
@ -461,6 +462,7 @@
<ClInclude Include="..\vpklib\packedstore.h" />
<ClInclude Include="..\vstdlib\callback.h" />
<ClInclude Include="..\vstdlib\completion.h" />
<ClInclude Include="..\vstdlib\concommandhash.h" />
<ClInclude Include="..\vstdlib\keyvaluessystem.h" />
<ClInclude Include="..\vstdlib\random.h" />
<ClInclude Include="..\windows\console.h" />
@ -560,6 +562,7 @@
<ClCompile Include="..\tier1\characterset.cpp" />
<ClCompile Include="..\tier1\cmd.cpp" />
<ClCompile Include="..\tier1\cvar.cpp" />
<ClCompile Include="..\tier1\generichash.cpp" />
<ClCompile Include="..\tier1\IConVar.cpp" />
<ClCompile Include="..\tier1\NetAdr2.cpp" />
<ClCompile Include="..\tier1\splitstring.cpp" />

9
r5dev/vproj/dedicated.vcxproj.filters
View File

@ -1224,6 +1224,12 @@
<ClInclude Include="..\tier0\annotations.h">
<Filter>sdk\tier0</Filter>
</ClInclude>
<ClInclude Include="..\tier1\utllinkedlist.h">
<Filter>sdk\tier1</Filter>
</ClInclude>
<ClInclude Include="..\vstdlib\concommandhash.h">
<Filter>sdk\vstdlib</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\common\opcodes.cpp">
@ -1529,6 +1535,9 @@
<ClCompile Include="..\networksystem\bansystem.cpp">
<Filter>sdk\networksystem</Filter>
</ClCompile>
<ClCompile Include="..\tier1\generichash.cpp">
<Filter>sdk\tier1</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\Dedicated.def" />

3
r5dev/vproj/gamesdk.vcxproj
View File

@ -121,6 +121,7 @@
<ClCompile Include="..\tier1\characterset.cpp" />
<ClCompile Include="..\tier1\cmd.cpp" />
<ClCompile Include="..\tier1\cvar.cpp" />
<ClCompile Include="..\tier1\generichash.cpp" />
<ClCompile Include="..\tier1\IConVar.cpp" />
<ClCompile Include="..\tier1\NetAdr2.cpp" />
<ClCompile Include="..\tier1\splitstring.cpp" />
@ -515,6 +516,7 @@
<ClInclude Include="..\tier1\utlblockmemory.h" />
<ClInclude Include="..\tier1\utldict.h" />
<ClInclude Include="..\tier1\utlfixedmemory.h" />
<ClInclude Include="..\tier1\utllinkedlist.h" />
<ClInclude Include="..\tier1\utlmemory.h" />
<ClInclude Include="..\tier1\utlrbtree.h" />
<ClInclude Include="..\tier1\utlvector.h" />
@ -534,6 +536,7 @@
<ClInclude Include="..\vpklib\packedstore.h" />
<ClInclude Include="..\vstdlib\callback.h" />
<ClInclude Include="..\vstdlib\completion.h" />
<ClInclude Include="..\vstdlib\concommandhash.h" />
<ClInclude Include="..\vstdlib\keyvaluessystem.h" />
<ClInclude Include="..\vstdlib\random.h" />
<ClInclude Include="..\windows\console.h" />

9
r5dev/vproj/gamesdk.vcxproj.filters
View File

@ -612,6 +612,9 @@
<ClCompile Include="..\networksystem\bansystem.cpp">
<Filter>sdk\networksystem</Filter>
</ClCompile>
<ClCompile Include="..\tier1\generichash.cpp">
<Filter>sdk\tier1</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\client\cdll_engine_int.h">
@ -1790,6 +1793,12 @@
<ClInclude Include="..\tier0\annotations.h">
<Filter>sdk\tier0</Filter>
</ClInclude>
<ClInclude Include="..\vstdlib\concommandhash.h">
<Filter>sdk\vstdlib</Filter>
</ClInclude>
<ClInclude Include="..\tier1\utllinkedlist.h">
<Filter>sdk\tier1</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Image Include="..\shared\resource\lockedserver.png">

214
r5dev/vstdlib/concommandhash.h Normal file
View File

@ -0,0 +1,214 @@
//===== Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: Special case hash table for console commands
//
// $NoKeywords: $
//
//===========================================================================//
#if !defined( CONCOMMANDHASH_H )
#define CONCOMMANDHASH_H
#ifdef _WIN32
#pragma once
#endif
#include "tier1/cmd.h"
#include "tier1/utlvector.h"
#include "tier1/utllinkedlist.h"
#include "tier1/generichash.h"
// This is a hash table class very similar to the CUtlHashFast, but
// modified specifically so that we can look up ConCommandBases
// by string names without having to actually store those strings in
// the dictionary, and also iterate over all of them.
// It uses separate chaining: each key hashes to a bucket, each
// bucket is a linked list of hashed commands. We store the hash of
// the command's string name as well as its pointer, so we can do
// the linked list march part of the Find() operation more quickly.
class CConCommandHash
{
public:
typedef int64_t CCommandHashHandle_t; // confirmed 64-bit in r5 see [r5apex_ds.exe+0x597062]
typedef unsigned int HashKey_t;
// Constructor/Deconstructor.
CConCommandHash();
~CConCommandHash();
// Memory.
void Purge(bool bReinitialize);
// Invalid handle.
static CCommandHashHandle_t InvalidHandle(void) { return (CCommandHashHandle_t)~0; }
inline bool IsValidHandle(CCommandHashHandle_t hHash) const;
/// Initialize.
void Init(void); // bucket count is hardcoded in enum below.
/// Get hash value for a concommand
static inline HashKey_t Hash(const ConCommandBase* cmd);
// Size not available; count is meaningless for multilists.
// int Count( void ) const;
// Insertion.
CCommandHashHandle_t Insert(ConCommandBase* cmd);
CCommandHashHandle_t FastInsert(ConCommandBase* cmd);
// Removal.
void Remove(CCommandHashHandle_t hHash);
void RemoveAll(void);
// Retrieval.
inline CCommandHashHandle_t Find(const char* name) const;
CCommandHashHandle_t Find(const ConCommandBase* cmd) const;
// A convenience version of Find that skips the handle part
// and returns a pointer to a concommand, or NULL if none was found.
inline ConCommandBase* FindPtr(const char* name) const;
inline ConCommandBase*& operator[](CCommandHashHandle_t hHash);
inline ConCommandBase* const& operator[](CCommandHashHandle_t hHash) const;
//#ifdef _DEBUG
// Dump a report to MSG
void Report(void);
//#endif
// Iteration
struct CCommandHashIterator_t
{
int bucket;
CCommandHashHandle_t handle;
CCommandHashIterator_t(int _bucket, const CCommandHashHandle_t& _handle)
: bucket(_bucket), handle(_handle) {};
// inline operator UtlHashFastHandle_t() const { return handle; };
};
inline CCommandHashIterator_t First() const;
inline CCommandHashIterator_t Next(const CCommandHashIterator_t& hHash) const;
inline bool IsValidIterator(const CCommandHashIterator_t& iter) const;
inline ConCommandBase*& operator[](const CCommandHashIterator_t& iter) { return (*this)[iter.handle]; }
inline ConCommandBase* const& operator[](const CCommandHashIterator_t& iter) const { return (*this)[iter.handle]; }
private:
// a find func where we've already computed the hash for the string.
// (hidden private in case we decide to invent a custom string hash func
// for this class)
CCommandHashHandle_t Find(const char* name, HashKey_t hash) const;
protected:
enum
{
kNUM_BUCKETS = 256,
kBUCKETMASK = kNUM_BUCKETS - 1,
};
struct HashEntry_t
{
HashKey_t m_uiKey;
ConCommandBase* m_Data;
HashEntry_t(unsigned int _hash, ConCommandBase* _cmd)
: m_uiKey(_hash), m_Data(_cmd) {};
HashEntry_t() {};
};
typedef CUtlFixedLinkedList<HashEntry_t> datapool_t;
CUtlVector<CCommandHashHandle_t> m_aBuckets;
datapool_t m_aDataPool;
};
inline bool CConCommandHash::IsValidHandle(CCommandHashHandle_t hHash) const
{
return m_aDataPool.IsValidIndex(hHash);
}
inline CConCommandHash::CCommandHashHandle_t CConCommandHash::Find(const char* name) const
{
return Find(name, HashStringCaseless(name));
}
inline ConCommandBase*& CConCommandHash::operator[](CCommandHashHandle_t hHash)
{
return (m_aDataPool[hHash].m_Data);
}
inline ConCommandBase* const& CConCommandHash::operator[](CCommandHashHandle_t hHash) const
{
return (m_aDataPool[hHash].m_Data);
}
//-----------------------------------------------------------------------------
// Purpose: For iterating over the whole hash, return the index of the first element
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashIterator_t CConCommandHash::First() const
{
// walk through the buckets to find the first one that has some data
int bucketCount = m_aBuckets.Count();
const CCommandHashHandle_t invalidIndex = m_aDataPool.InvalidIndex();
for (int bucket = 0; bucket < bucketCount; ++bucket)
{
CCommandHashHandle_t iElement = m_aBuckets[bucket]; // get the head of the bucket
if (iElement != invalidIndex)
return CCommandHashIterator_t(bucket, iElement);
}
// if we are down here, the list is empty
return CCommandHashIterator_t(-1, invalidIndex);
}
//-----------------------------------------------------------------------------
// Purpose: For iterating over the whole hash, return the next element after
// the param one. Or an invalid iterator.
//-----------------------------------------------------------------------------
CConCommandHash::CCommandHashIterator_t
CConCommandHash::Next(const CConCommandHash::CCommandHashIterator_t& iter) const
{
// look for the next entry in the current bucket
CCommandHashHandle_t next = m_aDataPool.Next(iter.handle);
const CCommandHashHandle_t invalidIndex = m_aDataPool.InvalidIndex();
if (next != invalidIndex)
{
// this bucket still has more elements in it
return CCommandHashIterator_t(iter.bucket, next);
}
// otherwise look for the next bucket with data
int bucketCount = m_aBuckets.Count();
for (int bucket = iter.bucket + 1; bucket < bucketCount; ++bucket)
{
CCommandHashHandle_t next = m_aBuckets[bucket]; // get the head of the bucket
if (next != invalidIndex)
return CCommandHashIterator_t(bucket, next);
}
// if we're here, there's no more data to be had
return CCommandHashIterator_t(-1, invalidIndex);
}
bool CConCommandHash::IsValidIterator(const CCommandHashIterator_t& iter) const
{
return ((iter.bucket >= 0) && (m_aDataPool.IsValidIndex(iter.handle)));
}
inline CConCommandHash::HashKey_t CConCommandHash::Hash(const ConCommandBase* cmd)
{
return HashStringCaseless(cmd->GetName());
}
inline ConCommandBase* CConCommandHash::FindPtr(const char* name) const
{
CCommandHashHandle_t handle = Find(name);
if (handle == InvalidHandle())
{
return NULL;
}
else
{
return (*this)[handle];
}
}
#endif