libclod
C library for interacting with NBTs, region files, LOD data and other things.
Loading...
Searching...
No Matches
integer_le.h
1#ifndef LIBCLOD_SERIALISE_INTEGER_LE_H
2#define LIBCLOD_SERIALISE_INTEGER_LE_H
3
4#include <clod/lib.h>
5#include <stdint.h>
6
8#define LEU8_MAX UINT8_C(0xFF)
10#define LEU16_MAX UINT16_C(0xFFFF)
12#define LEU24_MAX UINT32_C(0xFFFFFF)
14#define LEU32_MAX UINT32_C(0xFFFFFFFF)
16#define LEU40_MAX UINT64_C(0xFFFFFFFFFF)
18#define LEU48_MAX UINT64_C(0xFFFFFFFFFFFF)
20#define LEU56_MAX UINT64_C(0xFFFFFFFFFFFFFF)
22#define LEU64_MAX UINT64_C(0xFFFFFFFFFFFFFFFF)
23
25static inline void leu8_enc (uint8_t ptr[1], const uint8_t val) { ptr[0] = (uint8_t)val; }
27static inline void leu16_enc(uint8_t ptr[2], const uint16_t val) { ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
29static inline void leu24_enc(uint8_t ptr[3], const uint32_t val) { ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
31static inline void leu32_enc(uint8_t ptr[4], const uint32_t val) { ptr[3] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
33static inline void leu40_enc(uint8_t ptr[5], const uint64_t val) { ptr[4] = (uint8_t)(val >> 32); ptr[3] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
35static inline void leu48_enc(uint8_t ptr[6], const uint64_t val) { ptr[5] = (uint8_t)(val >> 40); ptr[4] = (uint8_t)(val >> 32); ptr[3] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
37static inline void leu56_enc(uint8_t ptr[7], const uint64_t val) { ptr[6] = (uint8_t)(val >> 48); ptr[5] = (uint8_t)(val >> 40); ptr[4] = (uint8_t)(val >> 32); ptr[3] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8 ); ptr[0] = (uint8_t)val; }
39static inline void leu64_enc(uint8_t ptr[8], const uint64_t val) { ptr[7] = (uint8_t)(val >> 56); ptr[6] = (uint8_t)(val >> 48); ptr[5] = (uint8_t)(val >> 40); ptr[4] = (uint8_t)(val >> 32); ptr[3] = (uint8_t)(val >> 24); ptr[2] = (uint8_t)(val >> 16); ptr[1] = (uint8_t)(val >> 8); ptr[0] = (uint8_t)val; }
40
42CLOD_PURE static inline uint8_t leu8_dec (const uint8_t ptr[1]) { return ptr[0]; }
44CLOD_PURE static inline uint16_t leu16_dec(const uint8_t ptr[2]) { return (uint16_t)ptr[1] << 8 | (uint16_t)ptr[0]; }
46CLOD_PURE static inline uint32_t leu24_dec(const uint8_t ptr[3]) { return (uint32_t)ptr[2] << 16 | (uint32_t)ptr[1] << 8 | (uint32_t)ptr[0]; }
48CLOD_PURE static inline uint32_t leu32_dec(const uint8_t ptr[4]) { return (uint32_t)ptr[3] << 24 | (uint32_t)ptr[2] << 16 | (uint32_t)ptr[1] << 8 | (uint32_t)ptr[0]; }
50CLOD_PURE static inline uint64_t leu40_dec(const uint8_t ptr[5]) { return (uint64_t)ptr[4] << 32 | (uint64_t)ptr[3] << 24 | (uint64_t)ptr[2] << 16 | (uint64_t)ptr[1] << 8 | (uint64_t)ptr[0]; }
52CLOD_PURE static inline uint64_t leu48_dec(const uint8_t ptr[6]) { return (uint64_t)ptr[5] << 40 | (uint64_t)ptr[4] << 32 | (uint64_t)ptr[3] << 24 | (uint64_t)ptr[2] << 16 | (uint64_t)ptr[1] << 8 | (uint64_t)ptr[0]; }
54CLOD_PURE static inline uint64_t leu56_dec(const uint8_t ptr[7]) { return (uint64_t)ptr[6] << 48 | (uint64_t)ptr[5] << 40 | (uint64_t)ptr[4] << 32 | (uint64_t)ptr[3] << 24 | (uint64_t)ptr[2] << 16 | (uint64_t)ptr[1] << 8 | (uint64_t)ptr[0]; }
56CLOD_PURE static inline uint64_t leu64_dec(const uint8_t ptr[8]) { return (uint64_t)ptr[7] << 56 | (uint64_t)ptr[6] << 48 | (uint64_t)ptr[5] << 40 | (uint64_t)ptr[4] << 32 | (uint64_t)ptr[3] << 24 | (uint64_t)ptr[2] << 16 | (uint64_t)ptr[1] << 8 | (uint64_t)ptr[0]; }
57
59#define LEI8_MIN INT8_C(-0x80)
61#define LEI16_MIN INT16_C(-0x8000)
63#define LEI24_MIN INT32_C(-0x800000)
65#define LEI32_MIN INT32_C(-0x80000000)
67#define LEI40_MIN INT64_C(-0x8000000000)
69#define LEI48_MIN INT64_C(-0x800000000000)
71#define LEI56_MIN INT64_C(-0x80000000000000)
73#define LEI64_MIN INT64_C(-0x8000000000000000)
74
76#define LEI8_MAX INT8_C(0x7F)
78#define LEI16_MAX INT16_C(0x7FFF)
80#define LEI24_MAX INT32_C(0x7FFFFF)
82#define LEI32_MAX INT32_C(0x7FFFFFFF)
84#define LEI40_MAX INT64_C(0x7FFFFFFFFF)
86#define LEI48_MAX INT64_C(0x7FFFFFFFFFFF)
88#define LEI56_MAX INT64_C(0x7FFFFFFFFFFFFF)
90#define LEI64_MAX INT64_C(0x7FFFFFFFFFFFFFFF)
91
93static inline void lei8_enc (uint8_t ptr[1], const int8_t val) { leu8_enc (ptr, (uint8_t )(val)); }
95static inline void lei16_enc(uint8_t ptr[2], const int16_t val) { leu16_enc(ptr, (uint16_t)(val)); }
97static inline void lei24_enc(uint8_t ptr[3], const int32_t val) { leu24_enc(ptr, (uint32_t)(val > LEI24_MAX ? LEI24_MAX : val < LEI24_MIN ? LEI24_MIN : val)); }
99static inline void lei32_enc(uint8_t ptr[4], const int32_t val) { leu32_enc(ptr, (uint32_t)(val)); }
101static inline void lei40_enc(uint8_t ptr[5], const int64_t val) { leu40_enc(ptr, (uint64_t)(val > LEI40_MAX ? LEI40_MAX : val < LEI40_MIN ? LEI40_MIN : val)); }
103static inline void lei48_enc(uint8_t ptr[6], const int64_t val) { leu48_enc(ptr, (uint64_t)(val > LEI48_MAX ? LEI48_MAX : val < LEI48_MIN ? LEI48_MIN : val)); }
105static inline void lei56_enc(uint8_t ptr[7], const int64_t val) { leu56_enc(ptr, (uint64_t)(val > LEI56_MAX ? LEI56_MAX : val < LEI56_MIN ? LEI56_MIN : val)); }
107static inline void lei64_enc(uint8_t ptr[8], const int64_t val) { leu64_enc(ptr, (uint64_t)(val)); }
108
110CLOD_PURE static inline int8_t lei8_dec (const uint8_t ptr[1]) { return (int8_t )(leu8_dec (ptr)); }
112CLOD_PURE static inline int16_t lei16_dec(const uint8_t ptr[2]) { return (int16_t)(leu16_dec(ptr)); }
114CLOD_PURE static inline int32_t lei24_dec(const uint8_t ptr[3]) { return (int32_t)(leu24_dec(ptr) << 8) >> 8; }
116CLOD_PURE static inline int32_t lei32_dec(const uint8_t ptr[4]) { return (int32_t)(leu32_dec(ptr)); }
118CLOD_PURE static inline int64_t lei40_dec(const uint8_t ptr[5]) { return (int64_t)(leu40_dec(ptr) << 24) >> 24; }
120CLOD_PURE static inline int64_t lei48_dec(const uint8_t ptr[6]) { return (int64_t)(leu48_dec(ptr) << 16) >> 16; }
122CLOD_PURE static inline int64_t lei56_dec(const uint8_t ptr[7]) { return (int64_t)(leu56_dec(ptr) << 8) >> 8; }
124CLOD_PURE static inline int64_t lei64_dec(const uint8_t ptr[8]) { return (int64_t)(leu64_dec(ptr)); }
125
127CLOD_CONST static inline uint8_t leuv_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 leuv_enc(uint8_t *ptr, const void *end, const uint64_t val) {
139 const uint8_t size = leuv_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 >> (i * 7) | 0b10000000);
144 i++;
145 }
146 if (ptr + i == end) return false;
147 ptr[i] = (uint8_t)(val >> (i * 7) & 0b01111111);
148 return true;
149}
150
153static inline bool leuv_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 |= (uint64_t)(ptr[i] & 0b01111111) << (i * 7);
158 i++;
159 }
160 if (ptr + i == end) return false;
161 ret |= (uint64_t)(ptr[i] & 0b01111111) << (i * 7);
162 *val = ret;
163 return true;
164}
165
167CLOD_CONST static inline uint8_t leiv_size(int64_t val) {
168 uint8_t ret = 1;
169 while (val > 0x3F || val < -0x40) {
170 ret++;
171 val >>= 7;
172 }
173 return ret;
174}
175
178static inline bool leiv_enc(uint8_t *ptr, const void *end, const int64_t val) {
179 const uint8_t size = leiv_size(val);
180 uint8_t i = 0;
181 while (i + 1 < size) {
182 if (ptr + i == end) return false;
183 ptr[i] = (uint8_t)(val >> (i * 7) | 0b10000000);
184 i++;
185 }
186 if (ptr + i == end) return false;
187 ptr[i] = (uint8_t)((uint64_t)val >> (i * 7) & 0b01111111);
188 return true;
189}
190
193static inline bool leiv_dec(const uint8_t *ptr, const void *end, int64_t *val) {
194 int64_t ret = 0;
195 uint8_t i = 0;
196 while (i < 9 && ptr + i != end && ptr[i] & 0b10000000) {
197 ret |= (int64_t)(ptr[i] & 0b01111111) << (i * 7);
198 i++;
199 }
200 if (ptr + i == end) return false;
201 ret |= (int64_t)(uint64_t)(ptr[i] & 0b01111111) << (i * 7);
202 if (i < 9 && ptr[i] & 0b01000000) ret |= (int64_t)(~UINT64_C(0) << ((i + 1) * 7));
203 *val = ret;
204 return true;
205}
206
207#endif