cryptutils

// util/endian.h, version 1.0.2

// Endian header file from libutil

// Copyright (C) 2021, Jakob Wakeling

// MIT Licence

#ifndef UTIL_ENDIAN_H_G7AID2RQ

#define UTIL_ENDIAN_H_G7AID2RQ

#ifdef __cplusplus

extern "C" {

#endif

#include <stdint.h>

/* Byte swap a 16-bit integer */

#define BSWAP16(x) ( \

	(((uint16_t)(x) & 0xFF00u) >> 8) | \

	(((uint16_t)(x) & 0x00FFu) << 8))

/* Byte swap a 32-bit integer */

#define BSWAP32(x) ( \

	(((uint32_t)(x) & 0xFF000000uL) >> 24) | \

	(((uint32_t)(x) & 0x00FF0000uL) >>  8) | \

	(((uint32_t)(x) & 0x0000FF00uL) <<  8) | \

	(((uint32_t)(x) & 0x000000FFuL) << 24))

/* Byte swap a 64-bit integer */

#define BSWAP64(x) ( \

	(((uint64_t)(x) & 0xFF00000000000000uLL) >> 56) | \

	(((uint64_t)(x) & 0x00FF000000000000uLL) >> 40) | \

	(((uint64_t)(x) & 0x0000FF0000000000uLL) >> 24) | \

	(((uint64_t)(x) & 0x000000FF00000000uLL) >>  8) | \

	(((uint64_t)(x) & 0x00000000FF000000uLL) <<  8) | \

	(((uint64_t)(x) & 0x0000000000FF0000uLL) << 24) | \

	(((uint64_t)(x) & 0x000000000000FF00uLL) << 40) | \

	(((uint64_t)(x) & 0x00000000000000FFuLL) << 56))

/* Load a 16-bit little endian integer */

#define LD16LE(p) ( \

	((uint16_t)(((uint8_t *)(p))[0]) << 0) | \

	((uint16_t)(((uint8_t *)(p))[1]) << 8))

/* Load a 16-bit big endian integer */

#define LD16BE(p) ( \

	((uint16_t)(((uint8_t *)(p))[0]) << 8) | \

	((uint16_t)(((uint8_t *)(p))[1]) << 0))

/* Load a 32-bit little endian integer */

#define LD32LE(p) ( \

	((uint32_t)(((uint8_t *)(p))[0]) <<  0) | \

	((uint32_t)(((uint8_t *)(p))[1]) <<  8) | \

	((uint32_t)(((uint8_t *)(p))[2]) << 16) | \

	((uint32_t)(((uint8_t *)(p))[3]) << 24))

/* Load a 32-bit big endian integer */

#define LD32BE(p) ( \

	((uint32_t)(((uint8_t *)(p))[0]) << 24) | \

	((uint32_t)(((uint8_t *)(p))[1]) << 16) | \

	((uint32_t)(((uint8_t *)(p))[2]) <<  8) | \

	((uint32_t)(((uint8_t *)(p))[3]) <<  0))

/* Load a 64-bit little endian integer */

#define LD64LE(p) ( \

	((uint64_t)(((uint8_t *)(p))[0]) <<  0) | \

	((uint64_t)(((uint8_t *)(p))[1]) <<  8) | \

	((uint64_t)(((uint8_t *)(p))[2]) << 16) | \

	((uint64_t)(((uint8_t *)(p))[3]) << 24) | \

	((uint64_t)(((uint8_t *)(p))[4]) << 32) | \

	((uint64_t)(((uint8_t *)(p))[5]) << 40) | \

	((uint64_t)(((uint8_t *)(p))[6]) << 48) | \

	((uint64_t)(((uint8_t *)(p))[7]) << 56))

/* Load a 64-bit big endian integer */

#define LD64BE(p) ( \

	((uint64_t)(((uint8_t *)(p))[0]) << 56) | \

	((uint64_t)(((uint8_t *)(p))[1]) << 48) | \

	((uint64_t)(((uint8_t *)(p))[2]) << 40) | \

	((uint64_t)(((uint8_t *)(p))[3]) << 32) | \

	((uint64_t)(((uint8_t *)(p))[4]) << 24) | \

	((uint64_t)(((uint8_t *)(p))[5]) << 16) | \

	((uint64_t)(((uint8_t *)(p))[6]) <<  8) | \

	((uint64_t)(((uint8_t *)(p))[7]) <<  0))

/* Store a 16-bit little endian integer */

#define ST16LE(p, x) \

	((uint8_t *)(p))[0] = ((uint16_t)(x) >> 0) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint16_t)(x) >> 8) & 0xFFu

/* Store a 16-bit big endian integer */

#define ST16BE(p, x) \

	((uint8_t *)(p))[0] = ((uint16_t)(x) >> 8) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint16_t)(x) >> 0) & 0xFFu

/* Store a 32-bit little endian integer */

#define ST32LE(p, x) \

	((uint8_t *)(p))[0] = ((uint32_t)(x) >>  0) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint32_t)(x) >>  8) & 0xFFu; \

	((uint8_t *)(p))[2] = ((uint32_t)(x) >> 16) & 0xFFu; \

	((uint8_t *)(p))[3] = ((uint32_t)(x) >> 24) & 0xFFu

/* Store a 32-bit big endian integer */

#define ST32BE(p, x) \

	((uint8_t *)(p))[0] = ((uint32_t)(x) >> 24) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint32_t)(x) >> 16) & 0xFFu; \

	((uint8_t *)(p))[2] = ((uint32_t)(x) >>  8) & 0xFFu; \

	((uint8_t *)(p))[3] = ((uint32_t)(x) >>  0) & 0xFFu

/* Store a 64-bit little endian integer */

#define ST64LE(p, x) \

	((uint8_t *)(p))[0] = ((uint64_t)(x) >>  0) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint64_t)(x) >>  8) & 0xFFu; \

	((uint8_t *)(p))[2] = ((uint64_t)(x) >> 16) & 0xFFu; \

	((uint8_t *)(p))[3] = ((uint64_t)(x) >> 24) & 0xFFu; \

	((uint8_t *)(p))[4] = ((uint64_t)(x) >> 32) & 0xFFu; \

	((uint8_t *)(p))[5] = ((uint64_t)(x) >> 40) & 0xFFu; \

	((uint8_t *)(p))[6] = ((uint64_t)(x) >> 48) & 0xFFu; \

	((uint8_t *)(p))[7] = ((uint64_t)(x) >> 56) & 0xFFu

/* Store a 64-bit big endian integer */

#define ST64BE(p, x) \

	((uint8_t *)(p))[0] = ((uint64_t)(x) >> 56) & 0xFFu; \

	((uint8_t *)(p))[1] = ((uint64_t)(x) >> 48) & 0xFFu; \

	((uint8_t *)(p))[2] = ((uint64_t)(x) >> 40) & 0xFFu; \

	((uint8_t *)(p))[3] = ((uint64_t)(x) >> 32) & 0xFFu; \

	((uint8_t *)(p))[4] = ((uint64_t)(x) >> 24) & 0xFFu; \

	((uint8_t *)(p))[5] = ((uint64_t)(x) >> 16) & 0xFFu; \

	((uint8_t *)(p))[6] = ((uint64_t)(x) >>  8) & 0xFFu; \

	((uint8_t *)(p))[7] = ((uint64_t)(x) >>  0) & 0xFFu

#ifdef __cplusplus

} // extern "C"

#endif

#endif // UTIL_ENDIAN_H_G7AID2RQ