[digest-highwayhash.git] / HighwayHash.xs

#define PERL_NO_GET_CONTEXT
#define MATH_INT64_NATIVE_IF_AVAILABLE
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "perl_math_int64.h"
#include "ppport.h"

#include "highwayhash.c"

typedef HighwayHashCat* Digest__HighwayHash;

void process_key(pTHX_ AV *key_av, uint64_t *key) {
	int i;
	SV *elt;

	if(av_len(key_av) + 1 != 4)
		croak("Key for highway_hash must be a 4-element array");
	for(i = 0 ; i < 4 ; i++) {
		elt = *av_fetch(key_av, i, 0);
		if(SvU64OK(elt))
			key[i] = SvU64(elt);
		else
			key[i] = SvUV(elt);
	}
}

uint64_t highway_hash64(AV *key_av, unsigned char *bytes, size_t size) {
	dTHX;
	uint64_t key[4];
	process_key(aTHX_ key_av, key);
	return HighwayHash64(bytes, size, key);
}

AV* highway_hash128(AV *key_av, unsigned char *bytes, size_t size) {
	dTHX;
	AV* result;
	uint64_t key[4];
	uint64_t hash[2];
	process_key(aTHX_ key_av, key);
	HighwayHash128(bytes, size, key, hash);
	result = newAV();
	av_push(result, sv_2mortal(newSVu64(hash[0])));
	av_push(result, sv_2mortal(newSVu64(hash[1])));
	return result;
}

AV* highway_hash256(AV *key_av, unsigned char *bytes, size_t size) {
	dTHX;
	AV* result;
	uint64_t key[4];
	uint64_t hash[4];
	process_key(aTHX_ key_av, key);
	HighwayHash256(bytes, size, key, hash);
	result = newAV();
	av_push(result, sv_2mortal(newSVu64(hash[0])));
	av_push(result, sv_2mortal(newSVu64(hash[1])));
	av_push(result, sv_2mortal(newSVu64(hash[2])));
	av_push(result, sv_2mortal(newSVu64(hash[3])));
	return result;
}

Digest__HighwayHash new(AV *key_av) {
	dTHX;
	uint64_t key[4];
	Digest__HighwayHash state;
	Newx(state, 1, HighwayHashCat);
	process_key(aTHX_ key_av, key);
	HighwayHashCatStart(key, state);
	return state;
}

void append(Digest__HighwayHash state, unsigned char *bytes, size_t size) {
	HighwayHashCatAppend(bytes, size, state);
}

uint64_t finish64(Digest__HighwayHash state) {
	return HighwayHashCatFinish64(state);
}

AV* finish128(Digest__HighwayHash state) {
	dTHX;
	AV* result;
	uint64_t hash[2];
	HighwayHashCatFinish128(state, hash);
	result = newAV();
	av_push(result, sv_2mortal(newSVu64(hash[0])));
	av_push(result, sv_2mortal(newSVu64(hash[1])));
	return result;
}

AV* finish256(Digest__HighwayHash state) {
	dTHX;
	AV* result;
	uint64_t hash[4];
	HighwayHashCatFinish256(state, hash);
	result = newAV();
	av_push(result, sv_2mortal(newSVu64(hash[0])));
	av_push(result, sv_2mortal(newSVu64(hash[1])));
	av_push(result, sv_2mortal(newSVu64(hash[2])));
	av_push(result, sv_2mortal(newSVu64(hash[3])));
	return result;
}

MODULE = Digest::HighwayHash		PACKAGE = Digest::HighwayHash
PROTOTYPES: DISABLE
BOOT:
     PERL_MATH_INT64_LOAD_OR_CROAK;

uint64_t highway_hash64(AV *key_av, unsigned char *bytes, size_t length(bytes))

AV* highway_hash128(AV *key_av, unsigned char *bytes, size_t length(bytes))

AV* highway_hash256(AV *key_av, unsigned char *bytes, size_t length(bytes))

Digest::HighwayHash new(SV *class, AV *key_av)
C_ARGS: key_av

void append(Digest::HighwayHash state, unsigned char *bytes, size_t length(bytes))

uint64_t finish64(Digest::HighwayHash state)

AV* finish128(Digest::HighwayHash state)

AV* finish256(Digest::HighwayHash state)
Commit	Line	Data
096619f2 MG	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
902280ce MG	12	typedef HighwayHashCat* Digest__HighwayHash;
902280ce MG	13
096619f2 MG	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++) {
af6c7941	21	elt = *av_fetch(key_av, i, 0);
096619f2 MG	22	if(SvU64OK(elt))
	23	key[i] = SvU64(elt);
	24	else
	25	key[i] = SvUV(elt);
	26	}
	27	}
	28
902280ce	29	uint64_t highway_hash64(AV key_av, unsigned char bytes, size_t size) {
096619f2 MG	30	dTHX;
	31	uint64_t key[4];
	32	process_key(aTHX_ key_av, key);
	33	return HighwayHash64(bytes, size, key);
	34	}
	35
902280ce	36	AV* highway_hash128(AV key_av, unsigned char bytes, size_t size) {
096619f2 MG	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
902280ce	49	AV* highway_hash256(AV key_av, unsigned char bytes, size_t size) {
096619f2 MG	50	dTHX;
	51	AV* result;
	52	uint64_t key[4];
beb05fe5	53	uint64_t hash[4];
096619f2 MG	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
902280ce MG	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
096619f2	106	MODULE = Digest::HighwayHash PACKAGE = Digest::HighwayHash
373437ea	107	PROTOTYPES: DISABLE
096619f2 MG	108	BOOT:
	109	PERL_MATH_INT64_LOAD_OR_CROAK;
	110
902280ce MG	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)
096619f2	123
902280ce	124	AV* finish128(Digest::HighwayHash state)
096619f2	125
902280ce	126	AV* finish256(Digest::HighwayHash state)