-/*-----------------------------------------------------------------------------
- * Core murmurhash algorithm macros */
-
-#define MURMUR_C1 (0xcc9e2d51)
-#define MURMUR_C2 (0x1b873593)
-#define MURMUR_C3 (0xe6546b64)
-#define MURMUR_C4 (0x85ebca6b)
-#define MURMUR_C5 (0xc2b2ae35)
-
-/* This is the main processing body of the algorithm. It operates
- * on each full 32-bits of input. */
-#define MURMUR_DOBLOCK(h1, k1) STMT_START { \
- k1 *= MURMUR_C1; \
- k1 = ROTL32(k1,15); \
- k1 *= MURMUR_C2; \
- \
- h1 ^= k1; \
- h1 = ROTL32(h1,13); \
- h1 = h1 * 5 + MURMUR_C3; \
-} STMT_END
-
-
-/* Append unaligned bytes to carry, forcing hash churn if we have 4 bytes */
-/* cnt=bytes to process, h1=name of h1 var, c=carry, n=bytes in c, ptr/len=payload */
-#define MURMUR_DOBYTES(cnt, h1, c, n, ptr, len) STMT_START { \
- int MURMUR_DOBYTES_i = cnt; \
- while(MURMUR_DOBYTES_i--) { \
- c = c>>8 | *ptr++<<24; \
- n++; len--; \
- if(n==4) { \
- MURMUR_DOBLOCK(h1, c); \
- n = 0; \
- } \
- } \
-} STMT_END
-
-
-/* now we create the hash function */
-PERL_STATIC_INLINE U32
-S_perl_hash_murmur3(const unsigned char * const seed, const unsigned char *ptr, STRLEN len) {
- U32 h1 = *((U32*)seed);
- U32 k1;
- U32 carry = 0;
-
- const unsigned char *end;
- int bytes_in_carry = 0; /* bytes in carry */
- I32 total_length= len;
-
-#if defined(UNALIGNED_SAFE)
- /* Handle carry: commented out as its only used in incremental mode - it never fires for us
- int i = (4-n) & 3;
- if(i && i <= len) {
- MURMUR_DOBYTES(i, h1, carry, bytes_in_carry, ptr, len);
- }
- */
-
- /* This CPU handles unaligned word access */
- /* Process 32-bit chunks */
- end = ptr + len/4*4;
- for( ; ptr < end ; ptr+=4) {
- k1 = U8TO32_LE(ptr);
- MURMUR_DOBLOCK(h1, k1);
- }
-#else
- /* This CPU does not handle unaligned word access */
-
- /* Consume enough so that the next data byte is word aligned */
- int i = -(long)ptr & 3;
- if(i && (STRLEN)i <= len) {
- MURMUR_DOBYTES(i, h1, carry, bytes_in_carry, ptr, len);
- }
-
- /* We're now aligned. Process in aligned blocks. Specialise for each possible carry count */
- end = ptr + len/4*4;
- switch(bytes_in_carry) { /* how many bytes in carry */
- case 0: /* c=[----] w=[3210] b=[3210]=w c'=[----] */
- for( ; ptr < end ; ptr+=4) {
- k1 = U8TO32_LE(ptr);
- MURMUR_DOBLOCK(h1, k1);
- }
- break;
- case 1: /* c=[0---] w=[4321] b=[3210]=c>>24|w<<8 c'=[4---] */
- for( ; ptr < end ; ptr+=4) {
- k1 = carry>>24;
- carry = U8TO32_LE(ptr);
- k1 |= carry<<8;
- MURMUR_DOBLOCK(h1, k1);
- }
- break;
- case 2: /* c=[10--] w=[5432] b=[3210]=c>>16|w<<16 c'=[54--] */
- for( ; ptr < end ; ptr+=4) {
- k1 = carry>>16;
- carry = U8TO32_LE(ptr);
- k1 |= carry<<16;
- MURMUR_DOBLOCK(h1, k1);
- }
- break;
- case 3: /* c=[210-] w=[6543] b=[3210]=c>>8|w<<24 c'=[654-] */
- for( ; ptr < end ; ptr+=4) {
- k1 = carry>>8;
- carry = U8TO32_LE(ptr);
- k1 |= carry<<24;
- MURMUR_DOBLOCK(h1, k1);
- }
- }
-#endif
- /* Advance over whole 32-bit chunks, possibly leaving 1..3 bytes */
- len -= len/4*4;
-
- /* Append any remaining bytes into carry */
- MURMUR_DOBYTES(len, h1, carry, bytes_in_carry, ptr, len);
-
- if (bytes_in_carry) {
- k1 = carry >> ( 4 - bytes_in_carry ) * 8;
- k1 *= MURMUR_C1;
- k1 = ROTL32(k1,15);
- k1 *= MURMUR_C2;
- h1 ^= k1;
- }
- h1 ^= total_length;
-
- /* fmix */
- h1 ^= h1 >> 16;
- h1 *= MURMUR_C4;
- h1 ^= h1 >> 13;
- h1 *= MURMUR_C5;
- h1 ^= h1 >> 16;
- return h1;
-}
-
-
-PERL_STATIC_INLINE U32
-S_perl_hash_djb2(const unsigned char * const seed, const unsigned char *str, const STRLEN len) {
- const unsigned char * const end = (const unsigned char *)str + len;
- U32 hash = *((U32*)seed + len);
- while (str < end) {
- hash = ((hash << 5) + hash) + *str++;
- }
- return hash;
-}
-
-PERL_STATIC_INLINE U32
-S_perl_hash_sdbm(const unsigned char * const seed, const unsigned char *str, const STRLEN len) {
- const unsigned char * const end = (const unsigned char *)str + len;
- U32 hash = *((U32*)seed + len);
- while (str < end) {
- hash = (hash << 6) + (hash << 16) - hash + *str++;
- }
- return hash;
-}
-
-
-/* This is the "One-at-a-Time" algorithm by Bob Jenkins
- * from requirements by Colin Plumb.
- * (http://burtleburtle.net/bob/hash/doobs.html)
- * With seed/len tweak.
- * */
-PERL_STATIC_INLINE U32
-S_perl_hash_one_at_a_time(const unsigned char * const seed, const unsigned char *str, const STRLEN len) {
- const unsigned char * const end = (const unsigned char *)str + len;
- U32 hash = *((U32*)seed) + len;
- while (str < end) {
- hash += *str++;
- hash += (hash << 10);
- hash ^= (hash >> 6);
- }
- hash += (hash << 3);
- hash ^= (hash >> 11);
- return (hash + (hash << 15));
-}
-
-/* Derived from "One-at-a-Time" algorithm by Bob Jenkins */
-PERL_STATIC_INLINE U32
-S_perl_hash_one_at_a_time_hard(const unsigned char * const seed, const unsigned char *str, const STRLEN len) {
- const unsigned char * const end = (const unsigned char *)str + len;
- U32 hash = *((U32*)seed) + len;
-
- while (str < end) {
- hash += (hash << 10);
- hash ^= (hash >> 6);
- hash += *str++;
- }
-
- hash += (hash << 10);
- hash ^= (hash >> 6);
- hash += seed[4];
-
- hash += (hash << 10);
- hash ^= (hash >> 6);
- hash += seed[5];
-
- hash += (hash << 10);
- hash ^= (hash >> 6);
- hash += seed[6];
-
- hash += (hash << 10);
- hash ^= (hash >> 6);
- hash += seed[7];
-
- hash += (hash << 10);
- hash ^= (hash >> 6);
-
- hash += (hash << 3);
- hash ^= (hash >> 11);
- return (hash + (hash << 15));
-}
-
-PERL_STATIC_INLINE U32
-S_perl_hash_old_one_at_a_time(const unsigned char * const seed, const unsigned char *str, const STRLEN len) {
- const unsigned char * const end = (const unsigned char *)str + len;
- U32 hash = *((U32*)seed);
- while (str < end) {
- hash += *str++;
- hash += (hash << 10);
- hash ^= (hash >> 6);
- }
- hash += (hash << 3);
- hash ^= (hash >> 11);
- return (hash + (hash << 15));
-}
-
-/* legacy - only mod_perl should be doing this. */
-#ifdef PERL_HASH_INTERNAL_ACCESS
-#define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH(hash,str,len)
-#endif