HighwayHash.xs

   1 #define PERL_NO_GET_CONTEXT
   2 #define MATH_INT64_NATIVE_IF_AVAILABLE
   3 #include "EXTERN.h"
   4 #include "perl.h"
   5 #include "XSUB.h"
   6
   7 #include "perl_math_int64.h"
   8 #include "ppport.h"
   9
  10 #include "highwayhash.c"
  11
  12 typedef HighwayHashCat* Digest__HighwayHash;
  13
  14 void process_key(pTHX_ AV *key_av, uint64_t *key) {
  15         int i;
  16         SV *elt;
  17
  18         if(av_len(key_av) + 1 != 4)
  19                 croak("Key for highway_hash must be a 4-element array");
  20         for(i = 0 ; i < 4 ; i++) {
  21                 elt = *av_fetch(key_av, i, 0);
  22                 if(SvU64OK(elt))
  23                         key[i] = SvU64(elt);
  24                 else
  25                         key[i] = SvUV(elt);
  26         }
  27 }
  28
  29 uint64_t highway_hash64(AV *key_av, unsigned char *bytes, size_t size) {
  30         dTHX;
  31         uint64_t key[4];
  32         process_key(aTHX_ key_av, key);
  33         return HighwayHash64(bytes, size, key);
  34 }
  35
  36 AV* highway_hash128(AV *key_av, unsigned char *bytes, size_t size) {
  37         dTHX;
  38         AV* result;
  39         uint64_t key[4];
  40         uint64_t hash[2];
  41         process_key(aTHX_ key_av, key);
  42         HighwayHash128(bytes, size, key, hash);
  43         result = newAV();
  44         av_push(result, sv_2mortal(newSVu64(hash[0])));
  45         av_push(result, sv_2mortal(newSVu64(hash[1])));
  46         return result;
  47 }
  48
  49 AV* highway_hash256(AV *key_av, unsigned char *bytes, size_t size) {
  50         dTHX;
  51         AV* result;
  52         uint64_t key[4];
  53         uint64_t hash[4];
  54         process_key(aTHX_ key_av, key);
  55         HighwayHash256(bytes, size, key, hash);
  56         result = newAV();
  57         av_push(result, sv_2mortal(newSVu64(hash[0])));
  58         av_push(result, sv_2mortal(newSVu64(hash[1])));
  59         av_push(result, sv_2mortal(newSVu64(hash[2])));
  60         av_push(result, sv_2mortal(newSVu64(hash[3])));
  61         return result;
  62 }
  63
  64 Digest__HighwayHash new(AV *key_av) {
  65         dTHX;
  66         uint64_t key[4];
  67         Digest__HighwayHash state;
  68         Newx(state, 1, HighwayHashCat);
  69         process_key(aTHX_ key_av, key);
  70         HighwayHashCatStart(key, state);
  71         return state;
  72 }
  73
  74 void append(Digest__HighwayHash state, unsigned char *bytes, size_t size) {
  75         HighwayHashCatAppend(bytes, size, state);
  76 }
  77
  78 uint64_t finish64(Digest__HighwayHash state) {
  79         return HighwayHashCatFinish64(state);
  80 }
  81
  82 AV* finish128(Digest__HighwayHash state) {
  83         dTHX;
  84         AV* result;
  85         uint64_t hash[2];
  86         HighwayHashCatFinish128(state, hash);
  87         result = newAV();
  88         av_push(result, sv_2mortal(newSVu64(hash[0])));
  89         av_push(result, sv_2mortal(newSVu64(hash[1])));
  90         return result;
  91 }
  92
  93 AV* finish256(Digest__HighwayHash state) {
  94         dTHX;
  95         AV* result;
  96         uint64_t hash[4];
  97         HighwayHashCatFinish256(state, hash);
  98         result = newAV();
  99         av_push(result, sv_2mortal(newSVu64(hash[0])));
 100         av_push(result, sv_2mortal(newSVu64(hash[1])));
 101         av_push(result, sv_2mortal(newSVu64(hash[2])));
 102         av_push(result, sv_2mortal(newSVu64(hash[3])));
 103         return result;
 104 }
 105
 106 MODULE = Digest::HighwayHash            PACKAGE = Digest::HighwayHash
 107 PROTOTYPES: DISABLE
 108 BOOT:
 109      PERL_MATH_INT64_LOAD_OR_CROAK;
 110
 111 uint64_t highway_hash64(AV *key_av, unsigned char *bytes, size_t length(bytes))
 112
 113 AV* highway_hash128(AV *key_av, unsigned char *bytes, size_t length(bytes))
 114
 115 AV* highway_hash256(AV *key_av, unsigned char *bytes, size_t length(bytes))
 116
 117 Digest::HighwayHash new(SV *class, AV *key_av)
 118 C_ARGS: key_av
 119
 120 void append(Digest::HighwayHash state, unsigned char *bytes, size_t length(bytes))
 121
 122 uint64_t finish64(Digest::HighwayHash state)
 123
 124 AV* finish128(Digest::HighwayHash state)
 125
 126 AV* finish256(Digest::HighwayHash state)