6#ifndef CLOD_BIG_ENDIAN_H
7#define CLOD_BIG_ENDIAN_H
13static_assert(CHAR_BIT == 8);
14static_assert(__STDC_IEC_60559_BFP__,
"bit representation of floats must be ICE 559");
15static_assert(
sizeof(float) == 4);
16static_assert(
sizeof(double) == 8);
19#define BEU8_MAX UINT8_C(0xFF)
21#define BEU16_MAX UINT16_C(0xFFFF)
23#define BEU24_MAX UINT32_C(0xFFFFFF)
25#define BEU32_MAX UINT32_C(0xFFFFFFFF)
27#define BEU40_MAX UINT64_C(0xFFFFFFFFFF)
29#define BEU48_MAX UINT64_C(0xFFFFFFFFFFFF)
31#define BEU56_MAX UINT64_C(0xFFFFFFFFFFFFFF)
33#define BEU64_MAX UINT64_C(0xFFFFFFFFFFFFFFFF)
36CLOD_INLINE
static inline void beu8_enc (
char ptr[1],
const uint8_t val) { ptr[0] = (char)(val); }
38CLOD_INLINE
static inline void beu16_enc(
char ptr[2],
const uint16_t val) { ptr[0] = (char)(val >> 8 ); ptr[1] = (char)(val); }
40CLOD_INLINE
static inline void beu24_enc(
char ptr[3],
const uint32_t val) { ptr[0] = (char)(val >> 16); ptr[1] = (char)(val >> 8 ); ptr[2] = (char)(val); }
42CLOD_INLINE
static inline void beu32_enc(
char ptr[4],
const uint32_t val) { ptr[0] = (char)(val >> 24); ptr[1] = (char)(val >> 16); ptr[2] = (char)(val >> 8 ); ptr[3] = (char)(val); }
44CLOD_INLINE
static inline void beu40_enc(
char ptr[5],
const uint64_t val) { ptr[0] = (char)(val >> 32); ptr[1] = (char)(val >> 24); ptr[2] = (char)(val >> 16); ptr[3] = (char)(val >> 8 ); ptr[4] = (char)(val); }
46CLOD_INLINE
static inline void beu48_enc(
char ptr[6],
const uint64_t val) { ptr[0] = (char)(val >> 40); ptr[1] = (char)(val >> 32); ptr[2] = (char)(val >> 24); ptr[3] = (char)(val >> 16); ptr[4] = (char)(val >> 8 ); ptr[5] = (char)(val); }
48CLOD_INLINE
static inline void beu56_enc(
char ptr[7],
const uint64_t val) { ptr[0] = (char)(val >> 48); ptr[1] = (char)(val >> 40); ptr[2] = (char)(val >> 32); ptr[3] = (char)(val >> 24); ptr[4] = (char)(val >> 16); ptr[5] = (char)(val >> 8 ); ptr[6] = (char)(val); }
50CLOD_INLINE
static inline void beu64_enc(
char ptr[8],
const uint64_t val) { ptr[0] = (char)(val >> 56); ptr[1] = (char)(val >> 48); ptr[2] = (char)(val >> 40); ptr[3] = (char)(val >> 32); ptr[4] = (char)(val >> 24); ptr[5] = (char)(val >> 16); ptr[6] = (char)(val >> 8 ); ptr[7] = (char)(val); }
53CLOD_INLINE
static inline uint8_t
beu8_dec (
const char ptr[1]) {
return (uint8_t)ptr[0]; }
55CLOD_INLINE
static inline uint16_t
beu16_dec(
const char ptr[2]) {
return (uint16_t)((uint16_t)(uint8_t)ptr[0] << 8 | (uint16_t)(uint8_t)ptr[1]); }
57CLOD_INLINE
static inline uint32_t
beu24_dec(
const char ptr[3]) {
return (uint32_t)((uint32_t)(uint8_t)ptr[0] << 16 | (uint32_t)(uint8_t)ptr[1] << 8 | (uint32_t)(uint8_t)ptr[2]); }
59CLOD_INLINE
static inline uint32_t
beu32_dec(
const char ptr[4]) {
return (uint32_t)((uint32_t)(uint8_t)ptr[0] << 24 | (uint32_t)(uint8_t)ptr[1] << 16 | (uint32_t)(uint8_t)ptr[2] << 8 | (uint32_t)(uint8_t)ptr[3]); }
61CLOD_INLINE
static inline uint64_t
beu40_dec(
const char ptr[5]) {
return (uint64_t)((uint64_t)(uint8_t)ptr[0] << 32 | (uint64_t)(uint8_t)ptr[1] << 24 | (uint64_t)(uint8_t)ptr[2] << 16 | (uint64_t)(uint8_t)ptr[3] << 8 | (uint64_t)(uint8_t)ptr[4]); }
63CLOD_INLINE
static inline uint64_t
beu48_dec(
const char ptr[6]) {
return (uint64_t)((uint64_t)(uint8_t)ptr[0] << 40 | (uint64_t)(uint8_t)ptr[1] << 32 | (uint64_t)(uint8_t)ptr[2] << 24 | (uint64_t)(uint8_t)ptr[3] << 16 | (uint64_t)(uint8_t)ptr[4] << 8 | (uint64_t)(uint8_t)ptr[5]); }
65CLOD_INLINE
static inline uint64_t
beu56_dec(
const char ptr[7]) {
return (uint64_t)((uint64_t)(uint8_t)ptr[0] << 48 | (uint64_t)(uint8_t)ptr[1] << 40 | (uint64_t)(uint8_t)ptr[2] << 32 | (uint64_t)(uint8_t)ptr[3] << 24 | (uint64_t)(uint8_t)ptr[4] << 16 | (uint64_t)(uint8_t)ptr[5] << 8 | (uint64_t)(uint8_t)ptr[6]); }
67CLOD_INLINE
static inline uint64_t
beu64_dec(
const char ptr[8]) {
return (uint64_t)((uint64_t)(uint8_t)ptr[0] << 56 | (uint64_t)(uint8_t)ptr[1] << 48 | (uint64_t)(uint8_t)ptr[2] << 40 | (uint64_t)(uint8_t)ptr[3] << 32 | (uint64_t)(uint8_t)ptr[4] << 24 | (uint64_t)(uint8_t)ptr[5] << 16 | (uint64_t)(uint8_t)ptr[6] << 8 | (uint64_t)(uint8_t)ptr[7]); }
70#define BEI8_MIN INT8_C(-0x80)
72#define BEI16_MIN INT16_C(-0x8000)
74#define BEI24_MIN INT32_C(-0x800000)
76#define BEI32_MIN INT32_C(-0x80000000)
78#define BEI40_MIN INT64_C(-0x8000000000)
80#define BEI48_MIN INT64_C(-0x800000000000)
82#define BEI56_MIN INT64_C(-0x80000000000000)
84#define BEI64_MIN INT64_C(-0x8000000000000000)
87#define BEI8_MAX INT8_C(0x7F)
89#define BEI16_MAX INT16_C(0x7FFF)
91#define BEI24_MAX INT32_C(0x7FFFFF)
93#define BEI32_MAX INT32_C(0x7FFFFFFF)
95#define BEI40_MAX INT64_C(0x7FFFFFFFFF)
97#define BEI48_MAX INT64_C(0x7FFFFFFFFFFF)
99#define BEI56_MAX INT64_C(0x7FFFFFFFFFFFFF)
101#define BEI64_MAX INT64_C(0x7FFFFFFFFFFFFFFF)
104CLOD_INLINE
static inline void bei8_enc (
char ptr[1],
const int8_t val) {
beu8_enc (ptr, (uint8_t )(val)); }
106CLOD_INLINE
static inline void bei16_enc(
char ptr[2],
const int16_t val) {
beu16_enc(ptr, (uint16_t)(val)); }
110CLOD_INLINE
static inline void bei32_enc(
char ptr[4],
const int32_t val) {
beu32_enc(ptr, (uint32_t)(val)); }
118CLOD_INLINE
static inline void bei64_enc(
char ptr[8],
const int64_t val) {
beu64_enc(ptr, (uint64_t)(val)); }
121CLOD_INLINE
static inline int8_t
bei8_dec (
const char ptr[1]) {
return (int8_t )(
beu8_dec (ptr)); }
125CLOD_INLINE
static inline int32_t
bei24_dec(
const char ptr[3]) {
return (int32_t)(
beu24_dec(ptr) << 8) >> 8; }
129CLOD_INLINE
static inline int64_t
bei40_dec(
const char ptr[5]) {
return (int64_t)(
beu40_dec(ptr) << 24) >> 24; }
131CLOD_INLINE
static inline int64_t
bei48_dec(
const char ptr[6]) {
return (int64_t)(
beu48_dec(ptr) << 16) >> 16; }
133CLOD_INLINE
static inline int64_t
bei56_dec(
const char ptr[7]) {
return (int64_t)(
beu56_dec(ptr) << 8) >> 8; }
138CLOD_INLINE
static inline void bef32_enc(
char ptr[4],
const float f) {
const union {
float f; uint32_t i; } u = { f };
beu32_enc(ptr, u.i); }
140CLOD_INLINE
static inline void bef64_enc(
char ptr[8],
const double f) {
const union {
double f; uint64_t i; } u = { f };
beu64_enc(ptr, u.i); }
143CLOD_INLINE
static inline float bef32_dec(
const char ptr[4]) {
const union {
float f; uint32_t i; } u = { .i =
beu32_dec(ptr) };
return u.f; }
145CLOD_INLINE
static inline double bef64_dec(
const char ptr[8]) {
const union {
double f; uint64_t i; } u = { .i =
beu64_dec(ptr) };
return u.f; }
#define BEI40_MAX
Maximum 40-bit signed value.
#define BEI40_MIN
Minimum 40-bit signed value.
static void beu8_enc(char ptr[1], const uint8_t val)
Encode a 8-bit unsigned integer into big-endian format.
static int8_t bei8_dec(const char ptr[1])
Decode an 8-bit signed integer in big-endian format.
static uint32_t beu24_dec(const char ptr[3])
Decode a 24-bit unsigned integer in big-endian format.
static uint64_t beu64_dec(const char ptr[8])
Decode a 64-bit unsigned integer in big-endian format.
static void bei56_enc(char ptr[7], const int64_t val)
Encode a 56-bit signed integer into big-endian format.
static double bef64_dec(const char ptr[8])
Decode a double in big_endian format.
static void beu32_enc(char ptr[4], const uint32_t val)
Encode a 32-bit unsigned integer into big-endian format.
static uint64_t beu56_dec(const char ptr[7])
Decode a 56-bit unsigned integer in big-endian format.
static int64_t bei48_dec(const char ptr[6])
Decode a 48-bit signed integer in big-endian format.
static void beu56_enc(char ptr[7], const uint64_t val)
Encode a 56-bit unsigned integer into big-endian format.
static int32_t bei32_dec(const char ptr[4])
Decode a 32-bit signed integer in big-endian format.
#define BEI48_MIN
Minimum 48-bit signed value.
static void bei40_enc(char ptr[5], const int64_t val)
Encode a 40-bit signed integer into big-endian format.
#define BEI24_MAX
Maximum 24-bit signed value.
#define BEI56_MIN
Minimum 56-bit signed value.
static void beu64_enc(char ptr[8], const uint64_t val)
Encode a 64-bit unsigned integer into big-endian format.
static int32_t bei24_dec(const char ptr[3])
Decode a 24-bit signed integer in big-endian format.
static void beu48_enc(char ptr[6], const uint64_t val)
Encode a 48-bit unsigned integer into big-endian format.
static void beu40_enc(char ptr[5], const uint64_t val)
Encode a 40-bit unsigned integer into big-endian format.
static int16_t bei16_dec(const char ptr[2])
Decode a 16-bit signed integer in big-endian format.
static uint8_t beu8_dec(const char ptr[1])
Decode an 8-bit unsigned integer in big-endian format.
static void bei48_enc(char ptr[6], const int64_t val)
Encode a 48-bit signed integer into big-endian format.
static void bei32_enc(char ptr[4], const int32_t val)
Encode a 32-bit signed integer into big-endian format.
#define BEI24_MIN
Minimum 24-bit signed value.
static int64_t bei40_dec(const char ptr[5])
Decode a 40-bit signed integer in big-endian format.
static void bei64_enc(char ptr[8], const int64_t val)
Encode a 64-bit signed integer into big-endian format.
static void bei16_enc(char ptr[2], const int16_t val)
Encode a 16-bit signed integer into big-endian format.
static uint16_t beu16_dec(const char ptr[2])
Decode a 16-bit unsigned integer in big-endian format.
static void bef32_enc(char ptr[4], const float f)
Encode a float in big-endian format.
static void beu16_enc(char ptr[2], const uint16_t val)
Encode a 16-bit unsigned integer into big-endian format.
static uint64_t beu48_dec(const char ptr[6])
Decode a 48-bit unsigned integer in big-endian format.
#define BEI56_MAX
Maximum 56-bit signed value.
static float bef32_dec(const char ptr[4])
Decode a float in big_endian format.
static uint64_t beu40_dec(const char ptr[5])
Decode a 40-bit unsigned integer in big-endian format.
static void bei8_enc(char ptr[1], const int8_t val)
Encode an 8-bit signed integer into big-endian format.
static int64_t bei56_dec(const char ptr[7])
Decode a 56-bit signed integer in big-endian format.
static uint32_t beu32_dec(const char ptr[4])
Decode a 32-bit unsigned integer in big-endian format.
#define BEI48_MAX
Maximum 48-bit signed value.
static int64_t bei64_dec(const char ptr[8])
Decode a 64-bit signed integer in big-endian format.
static void bef64_enc(char ptr[8], const double f)
Encode a double in big-endian format.
static void bei24_enc(char ptr[3], const int32_t val)
Encode a 24-bit signed integer into big-endian format.
static void beu24_enc(char ptr[3], const uint32_t val)
Encode a 24-bit unsigned integer into big-endian format.
1.16.1