File Coverage

HighwayHash.xs
Criterion Covered Total %
statement 52 53 98.1
branch 7 10 70.0
condition n/a
subroutine n/a
pod n/a
total 59 63 93.6


line stmt bran cond sub pod time code
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 8           void process_key(pTHX_ AV *key_av, uint64_t *key) {
15             int i;
16             SV *elt;
17              
18 8 100         if(av_len(key_av) + 1 != 4)
19 2           croak("Key for highway_hash must be a 4-element array");
20 30 100         for(i = 0 ; i < 4 ; i++) {
21 24           elt = *av_fetch(key_av, i, 0);
22 24 50         if(SvU64OK(elt))
23 0           key[i] = SvU64(elt);
24             else
25 24 50         key[i] = SvUV(elt);
26             }
27 6           }
28              
29 1           uint64_t highway_hash64(AV *key_av, unsigned char *bytes, size_t size) {
30             dTHX;
31             uint64_t key[4];
32 1           process_key(aTHX_ key_av, key);
33 1           return HighwayHash64(bytes, size, key);
34             }
35              
36 2           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 2           process_key(aTHX_ key_av, key);
42 1           HighwayHash128(bytes, size, key, hash);
43 1           result = newAV();
44 1           av_push(result, sv_2mortal(newSVu64(hash[0])));
45 1           av_push(result, sv_2mortal(newSVu64(hash[1])));
46 1           return result;
47             }
48              
49 2           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 2           process_key(aTHX_ key_av, key);
55 1           HighwayHash256(bytes, size, key, hash);
56 1           result = newAV();
57 1           av_push(result, sv_2mortal(newSVu64(hash[0])));
58 1           av_push(result, sv_2mortal(newSVu64(hash[1])));
59 1           av_push(result, sv_2mortal(newSVu64(hash[2])));
60 1           av_push(result, sv_2mortal(newSVu64(hash[3])));
61 1           return result;
62             }
63              
64 3           Digest__HighwayHash new(AV *key_av) {
65             dTHX;
66             uint64_t key[4];
67             Digest__HighwayHash state;
68 3           Newx(state, 1, HighwayHashCat);
69 3           process_key(aTHX_ key_av, key);
70 3           HighwayHashCatStart(key, state);
71 3           return state;
72             }
73              
74 7           void append(Digest__HighwayHash state, unsigned char *bytes, size_t size) {
75 7           HighwayHashCatAppend(bytes, size, state);
76 7           }
77              
78 1           uint64_t finish64(Digest__HighwayHash state) {
79 1           return HighwayHashCatFinish64(state);
80             }
81              
82 1           AV* finish128(Digest__HighwayHash state) {
83             dTHX;
84             AV* result;
85             uint64_t hash[2];
86 1           HighwayHashCatFinish128(state, hash);
87 1           result = newAV();
88 1           av_push(result, sv_2mortal(newSVu64(hash[0])));
89 1           av_push(result, sv_2mortal(newSVu64(hash[1])));
90 1           return result;
91             }
92              
93 1           AV* finish256(Digest__HighwayHash state) {
94             dTHX;
95             AV* result;
96             uint64_t hash[4];
97 1           HighwayHashCatFinish256(state, hash);
98 1           result = newAV();
99 1           av_push(result, sv_2mortal(newSVu64(hash[0])));
100 1           av_push(result, sv_2mortal(newSVu64(hash[1])));
101 1           av_push(result, sv_2mortal(newSVu64(hash[2])));
102 1           av_push(result, sv_2mortal(newSVu64(hash[3])));
103 1           return result;
104             }
105              
106             MODULE = Digest::HighwayHash PACKAGE = Digest::HighwayHash
107             PROTOTYPES: DISABLE
108             BOOT:
109 1 50         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)