mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
f120354e96
* All libraries have been isolated from each other, and build into separate artifacts. * Project has been restructured to support isolating libraries. * CCrashHandler now calls a callback on crash (setup from core/dllmain.cpp, this can be setup in any way for any project. This callback is getting called when the apllication crashes. Useful for flushing buffers before closing handles to logging files for example). * Tier0 'CoreMsgV' function now calls a callback sink, which could be set by the user (currently setup to the SDK's internal logger in core/dllmain.cpp). TODO: * Add a batch file to autogenerate all projects. * Add support for dedicated server. * Add support for client dll. Bugs: * Game crashes on the title screen after the UI script compiler has finished (root cause unknown). * Curl error messages are getting logged twice for the dedicated server due to the removal of all "DEDICATED" preprocessor directives to support isolating projects. This has to be fixed properly!
431 lines
11 KiB
C++
431 lines
11 KiB
C++
//======= 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 "tier0_pch.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 * (uint32)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 = (int)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;
|
||
}
|