/* j/c/muk.c
**
*/
#include "all.h"
#include <murmur3.h>

/* functions
*/
  u3_noun
  u3qc_muk(u3_atom seed,
           u3_atom len,
           u3_atom key)
  {
    c3_w seed_w;
    c3_w len_w;
    c3_y *key_y;
    c3_w out_w;

    c3_assert( u3r_met(5, seed) <= 1 );
    c3_assert( u3r_met(0, len)  <= 31 );
    c3_assert( u3r_met(3, key)  <= len );

    seed_w = u3r_word(0, seed);
    len_w  = u3r_word(0, len);

    //  can't u3a_calloc 0 bytes
    //
    if ( 0 == len_w ) {
      key_y = 0;
    }
    else {
      key_y = u3a_calloc(sizeof(c3_y), len_w);
    }

    //  Efficiency: unnecessary copy.
    //
    //    We could calculate the hash directly against
    //    the atom internals, a la u3r_mug
    //
    u3r_bytes(0, len_w, key_y, key);

    MurmurHash3_x86_32(key_y, len_w, seed_w, &out_w);

    u3a_free(key_y);
    return u3i_words(1, &out_w);
  }

  u3_noun
  u3wc_muk(u3_noun cor)
  {
    u3_noun seed, len, key;

    if ( (c3n == u3r_mean(cor, u3x_sam_2, &seed,
                               u3x_sam_6, &len,
                               u3x_sam_7, &key, 0)) ||
         (c3n == u3ud(seed)) ||
         (c3n == u3ud(len))  ||
         (c3n == u3ud(key))  )
    {
      return u3m_bail(c3__exit);
    } else {
      return u3qc_muk(seed, len, key);
    }
  }