#define V3HTEST

/*
v3bhash. Suitable for fast non-cryptographic hashing.
http://cipherdev.org/

2011-03-16: updated mixing core. fixed padding again. added padding test :)
2010-10-26: the final block wasn't handled right if it was 10 or 11 bytes. oops.
2009-05-18: initial release

This file is released into the public domain through CC0. No rights reserved.
Legal stuff: http://creativecommons.org/publicdomain/zero/1.0/
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define rot(a,b) (((a)<<(b))|((a)>>(32-(b))))
#define MIX(a, b, c, d) \
    a=rot(a+d,21); b=rot(b,12)+c; c=c^a; d=d^b; \
    a=rot(a+d,19); b=rot(b,24)+c; c=c^a; d=d^b; \
    a=rot(a+d, 7); b=rot(b,12)+c; c=c^a; d=d^b; \
    a=rot(a+d,27); b=rot(b,17)+c; c=c^a; d=d^b;

uint32_t v3bhash(uint8_t *in, unsigned int len, uint32_t initval)
{
    unsigned int blocks = len/16,
                 remainder = len%16;
    register uint32_t m[4] = {len, initval, 11111111, 22222222};
    uint32_t *in32 = (uint32_t*)in,
             *fpos = &in32[blocks*4];

    // Mix initialization data (len, initval).
    MIX(m[0], m[1], m[2], m[3]);

    // Go through the input in 16-byte blocks.
    for(;in32<fpos;in32=&in32[4])
    {
        // Inject data. (unrolled for fun & profit)
        m[0]+=in32[0]; m[1]+=in32[1];
        m[2]+=in32[2]; m[3]+=in32[3];
        // Mix state.
        MIX(m[0], m[1], m[2], m[3]);
    }

    // Let's handle the remaining bytes.
    in = (uint8_t*)in32;
    switch(remainder)
    {
        case 15: m[3]^=in[14]<<16;
        case 14: m[3]^=in[13]<<8;
        case 13: m[3]^=in[12];
        case 12: m[2]^=in32[2];
                 m[1]^=in32[1];
                 m[0]^=in32[0];
                 break;
        case 11: m[3]^=in[10]<<8;
        case 10: m[3]^=in[ 9];
        case  9: m[2]^=in[ 8];
        case  8: m[1]^=in32[1];
                 m[0]^=in32[0];
                 break;
        case  7: m[3]^=in[ 6];
        case  6: m[2]^=in[ 5];
        case  5: m[1]^=in[ 4];
        case  4: m[0]^=in32[0];
                 break;
        case  3: m[2]^=in[ 2];
        case  2: m[1]^=in[ 1];
        case  1: m[0]^=in[ 0];
        case  0:;
    }

    // Mix the state for the remaining data.
    MIX(m[0], m[1], m[2], m[3]);

    // Do one final mix to avalanche everything.
    MIX(m[0], m[1], m[2], m[3]);

    // Note: m[] is actually a fine 128-bit hash, but only 32 bits are returned.
    return m[3]; // m[2] and m[3] are better than m[0] and m[1].
}

#ifdef V3HTEST
#define V3HTEST_LEN 64

int main()
{
    uint8_t data[V3HTEST_LEN];
    uint32_t res[2];
    unsigned int i, j, fail=0;
    for(i=0; i<V3HTEST_LEN; i++)
        data[i]=i;

    for(i=1; i<V3HTEST_LEN; i++)
    {
        res[0] = v3bhash(data, i, 0);
        for(j=0; j<V3HTEST_LEN; j++)
        {
            data[j] ^= 1;
            res[1] = v3bhash(data, i, 0);
            if((res[0]==res[1]) ^ (j>=i))
            {
                printf("byte %u not handled right at length %u\n", j, i);
                fail = 1;
            }
            data[j] ^= 1;
        }
    }

    printf("v3bhash padding test %s\n", fail ? "FAILED" : "ok");
    return fail;
}

#endif