libclod
C library for interacting with NBTs, region files, LOD data and other things.
Loading...
Searching...
No Matches
integer_be.h
1#ifndef LIBCLOD_SERIALISE_INTEGER_BE_H
2#define LIBCLOD_SERIALISE_INTEGER_BE_H
3
4#include <clod/lib.h>
5#include <stdint.h>
6
8#define BEU8_MAX UINT8_C(0xFF)
10#define BEU16_MAX UINT16_C(0xFFFF)
12#define BEU24_MAX UINT32_C(0xFFFFFF)
14#define BEU32_MAX UINT32_C(0xFFFFFFFF)
16#define BEU40_MAX UINT64_C(0xFFFFFFFFFF)
18#define BEU48_MAX UINT64_C(0xFFFFFFFFFFFF)
20#define BEU56_MAX UINT64_C(0xFFFFFFFFFFFFFF)
22#define BEU64_MAX UINT64_C(0xFFFFFFFFFFFFFFFF)
23
25static inline void beu8_enc (uint8_t ptr[1], const uint8_t val) { ptr[0] = val; }
27static inline void beu16_enc(uint8_t ptr[2], const uint16_t val) { ptr[0] = (uint8_t)(val >> 8); ptr[1] = (uint8_t)(val); }
29static inline void beu24_enc(uint8_t ptr[3], const uint32_t val) { ptr[0] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8); ptr[2] = (uint8_t)(val); }
31static inline void beu32_enc(uint8_t ptr[4], const uint32_t val) { ptr[0] = (uint8_t)(val >> 24); ptr[1] = (uint8_t)(val >> 16); ptr[2] = (uint8_t)(val >> 8); ptr[3] = (uint8_t)(val); }
33static inline void beu40_enc(uint8_t ptr[5], const uint64_t val) { ptr[0] = (uint8_t)(val >> 32); ptr[1] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[3] = (uint8_t)(val >> 8); ptr[4] = (uint8_t)(val); }
35static inline void beu48_enc(uint8_t ptr[6], const uint64_t val) { ptr[0] = (uint8_t)(val >> 40); ptr[1] = (uint8_t)(val >> 32); ptr[2] = (uint8_t)(val >> 24); ptr[3] = (uint8_t)(val >> 16); ptr[4] = (uint8_t)(val >> 8); ptr[5] = (uint8_t)(val); }
37static inline void beu56_enc(uint8_t ptr[7], const uint64_t val) { ptr[0] = (uint8_t)(val >> 48); ptr[1] = (uint8_t)(val >> 40); ptr[2] = (uint8_t)(val >> 32); ptr[3] = (uint8_t)(val >> 24); ptr[4] = (uint8_t)(val >> 16); ptr[5] = (uint8_t)(val >> 8); ptr[6] = (uint8_t)(val); }
39static inline void beu64_enc(uint8_t ptr[8], const uint64_t val) { ptr[0] = (uint8_t)(val >> 56); ptr[1] = (uint8_t)(val >> 48); ptr[2] = (uint8_t)(val >> 40); ptr[3] = (uint8_t)(val >> 32); ptr[4] = (uint8_t)(val >> 24); ptr[5] = (uint8_t)(val >> 16); ptr[6] = (uint8_t)(val >> 8); ptr[7] = (uint8_t)(val); }
40
42CLOD_PURE static inline uint8_t beu8_dec (const uint8_t ptr[1]) { return ptr[0]; }
44CLOD_PURE static inline uint16_t beu16_dec(const uint8_t ptr[2]) { return (uint16_t)(ptr[0] << 8 | ptr[1]); }
46CLOD_PURE static inline uint32_t beu24_dec(const uint8_t ptr[3]) { return (uint32_t)ptr[0] << 16 | (uint32_t)ptr[1] << 8 | (uint32_t)ptr[2]; }
48CLOD_PURE static inline uint32_t beu32_dec(const uint8_t ptr[4]) { return (uint32_t)ptr[0] << 24 | (uint32_t)ptr[1] << 16 | (uint32_t)ptr[2] << 8 | (uint32_t)ptr[3]; }
50CLOD_PURE static inline uint64_t beu40_dec(const uint8_t ptr[5]) { return (uint64_t)ptr[0] << 32 | (uint64_t)ptr[1] << 24 | (uint64_t)ptr[2] << 16 | (uint64_t)ptr[3] << 8 | (uint64_t)ptr[4]; }
52CLOD_PURE static inline uint64_t beu48_dec(const uint8_t ptr[6]) { return (uint64_t)ptr[0] << 40 | (uint64_t)ptr[1] << 32 | (uint64_t)ptr[2] << 24 | (uint64_t)ptr[3] << 16 | (uint64_t)ptr[4] << 8 | (uint64_t)ptr[5]; }
54CLOD_PURE static inline uint64_t beu56_dec(const uint8_t ptr[7]) { return (uint64_t)ptr[0] << 48 | (uint64_t)ptr[1] << 40 | (uint64_t)ptr[2] << 32 | (uint64_t)ptr[3] << 24 | (uint64_t)ptr[4] << 16 | (uint64_t)ptr[5] << 8 | (uint64_t)ptr[6]; }
56CLOD_PURE static inline uint64_t beu64_dec(const uint8_t ptr[8]) { return (uint64_t)ptr[0] << 56 | (uint64_t)ptr[1] << 48 | (uint64_t)ptr[2] << 40 | (uint64_t)ptr[3] << 32 | (uint64_t)ptr[4] << 24 | (uint64_t)ptr[5] << 16 | (uint64_t)ptr[6] << 8 | (uint64_t)ptr[7]; }
57
59#define BEI8_MIN INT8_C(-0x80)
61#define BEI16_MIN INT16_C(-0x8000)
63#define BEI24_MIN INT32_C(-0x800000)
65#define BEI32_MIN INT32_C(-0x80000000)
67#define BEI40_MIN INT64_C(-0x8000000000)
69#define BEI48_MIN INT64_C(-0x800000000000)
71#define BEI56_MIN INT64_C(-0x80000000000000)
73#define BEI64_MIN INT64_C(-0x8000000000000000)
74
76#define BEI8_MAX INT8_C(0x7F)
78#define BEI16_MAX INT16_C(0x7FFF)
80#define BEI24_MAX INT32_C(0x7FFFFF)
82#define BEI32_MAX INT32_C(0x7FFFFFFF)
84#define BEI40_MAX INT64_C(0x7FFFFFFFFF)
86#define BEI48_MAX INT64_C(0x7FFFFFFFFFFF)
88#define BEI56_MAX INT64_C(0x7FFFFFFFFFFFFF)
90#define BEI64_MAX INT64_C(0x7FFFFFFFFFFFFFFF)
91
93static inline void bei8_enc (uint8_t ptr[1], const int8_t val) { beu8_enc (ptr, (uint8_t )(val)); }
95static inline void bei16_enc(uint8_t ptr[2], const int16_t val) { beu16_enc(ptr, (uint16_t)(val)); }
97static inline void bei24_enc(uint8_t ptr[3], const int32_t val) { beu24_enc(ptr, (uint32_t)(val > BEI24_MAX ? BEI24_MAX : val < BEI24_MIN ? BEI24_MIN : val)); }
99static inline void bei32_enc(uint8_t ptr[4], const int32_t val) { beu32_enc(ptr, (uint32_t)(val)); }
101static inline void bei40_enc(uint8_t ptr[5], const int64_t val) { beu40_enc(ptr, (uint64_t)(val > BEI40_MAX ? BEI40_MAX : val < BEI40_MIN ? BEI40_MIN : val)); }
103static inline void bei48_enc(uint8_t ptr[6], const int64_t val) { beu48_enc(ptr, (uint64_t)(val > BEI48_MAX ? BEI48_MAX : val < BEI48_MIN ? BEI48_MIN : val)); }
105static inline void bei56_enc(uint8_t ptr[7], const int64_t val) { beu56_enc(ptr, (uint64_t)(val > BEI56_MAX ? BEI56_MAX : val < BEI56_MIN ? BEI56_MIN : val)); }
107static inline void bei64_enc(uint8_t ptr[8], const int64_t val) { beu64_enc(ptr, (uint64_t)(val)); }
108
110CLOD_PURE static inline int8_t bei8_dec (const uint8_t ptr[1]) { return (int8_t )(beu8_dec (ptr)); }
112CLOD_PURE static inline int16_t bei16_dec(const uint8_t ptr[2]) { return (int16_t)(beu16_dec(ptr)); }
114CLOD_PURE static inline int32_t bei24_dec(const uint8_t ptr[3]) { return (int32_t)(beu24_dec(ptr) << 8) >> 8; }
116CLOD_PURE static inline int32_t bei32_dec(const uint8_t ptr[4]) { return (int32_t)(beu32_dec(ptr)); }
118CLOD_PURE static inline int64_t bei40_dec(const uint8_t ptr[5]) { return (int64_t)(beu40_dec(ptr) << 24) >> 24; }
120CLOD_PURE static inline int64_t bei48_dec(const uint8_t ptr[6]) { return (int64_t)(beu48_dec(ptr) << 16) >> 16; }
122CLOD_PURE static inline int64_t bei56_dec(const uint8_t ptr[7]) { return (int64_t)(beu56_dec(ptr) << 8) >> 8; }
124CLOD_PURE static inline int64_t bei64_dec(const uint8_t ptr[8]) { return (int64_t)(beu64_dec(ptr)); }
125
127CLOD_CONST static inline uint8_t beuv_size(uint64_t val) {
128 uint8_t ret = 1;
129 while (val > 0x7F) {
130 ret++;
131 val >>= 7;
132 }
133 return ret;
134}
135
138static inline bool beuv_enc(uint8_t *ptr, const void *end, const uint64_t val) {
139 const uint8_t size = beuv_size(val);
140 uint8_t i = 0;
141 while (i + 1 < size) {
142 if (ptr + i == end) return false;
143 ptr[i] = (uint8_t)(val >> ((size - i - 1) * 7) | 0b10000000);
144 i++;
145 }
146 if (ptr + i == end) return false;
147 ptr[i] = (uint8_t)(val & 0b01111111);
148 return true;
149}
150
153static inline bool beuv_dec(const uint8_t *ptr, const void *end, uint64_t *val) {
154 uint64_t ret = 0;
155 uint8_t i = 0;
156 while (i < 9 && ptr + i != end && ptr[i] & 0b10000000) {
157 ret <<= 7;
158 ret |= (uint64_t)(ptr[i] & 0b01111111);
159 i++;
160 }
161 if (ptr + i == end) return false;
162 ret <<= 7;
163 ret |= (uint64_t)(ptr[i] & 0b01111111);
164 *val = ret;
165 return true;
166}
167
169CLOD_CONST static inline uint8_t beiv_size(int64_t val) {
170 uint8_t ret = 1;
171 while (val > 0x3F || val < -0x40) {
172 ret++;
173 val >>= 7;
174 }
175 return ret;
176}
177
180static inline bool beiv_enc(uint8_t *ptr, const void *end, const int64_t val) {
181 const uint8_t size = beiv_size(val);
182 uint8_t i = 0;
183 while (i + 1 < size) {
184 if (ptr + i == end) return false;
185 ptr[i] = (uint8_t)((uint64_t)val >> ((size - i - 1) * 7) | 0b10000000);
186 i++;
187 }
188 if (ptr + i == end) return false;
189 ptr[i] = (uint8_t)(val & 0b01111111);
190 return true;
191}
192
195static inline bool beiv_dec(const uint8_t *ptr, const void *end, int64_t *val) {
196 int64_t ret = 0;
197 uint8_t i = 0;
198 while (i < 9 && ptr + i != end && ptr[i] & 0b10000000) {
199 ret <<= 7;
200 ret |= (int64_t)(ptr[i] & 0b01111111);
201 i++;
202 }
203 if (ptr + i == end) return false;
204 ret <<= 7;
205 ret |= (int64_t)(ptr[i] & 0b01111111);
206 if (i < 9 && ptr[0] & 0b01000000) ret |= (int64_t)(UINT64_C(~0) << ((i + 1) * 7));
207 *val = ret;
208 return true;
209}
210
211#endif