diff options
Diffstat (limited to 'src/common/szbin.h')
| -rw-r--r-- | src/common/szbin.h | 248 |
1 files changed, 221 insertions, 27 deletions
diff --git a/src/common/szbin.h b/src/common/szbin.h index ac938ab..8524ae3 100644 --- a/src/common/szbin.h +++ b/src/common/szbin.h @@ -25,10 +25,17 @@ #define _COMMON_SZBIN_H +#include <assert.h> #include <malloc.h> #include <string.h> +#include "datatypes.h" +#include "io.h" +#include "leb128.h" +#include "sort.h" + + /* Structure associant données et taille */ typedef struct _sized_binary_t @@ -38,6 +45,9 @@ typedef struct _sized_binary_t const char *static_data; /* Données non modifiées */ char *data; /* Chaîne de caractères */ + const bin_t *static_bin_data; /* Données brutes non modifiées*/ + bin_t *bin_data; /* Données brutes */ + }; size_t size; /* Taille correspondante */ @@ -45,44 +55,228 @@ typedef struct _sized_binary_t } sized_binary_t; -#define init_sized_binary(sb) \ - do \ - { \ - (sb)->data = NULL; \ - (sb)->size = 0; \ - } \ +#define init_sized_binary(sb) \ + do \ + { \ + (sb)->data = NULL; \ + (sb)->size = 0; \ + } \ + while (0) + + +#define setup_sized_binary(sb, s) \ + do \ + { \ + (sb)->data = malloc(s); \ + (sb)->size = s; \ + } \ while (0) -#define setup_sized_binary(sb, s) \ - do \ - { \ - (sb)->data = malloc(s); \ - (sb)->size = s; \ - } \ +#define setup_sized_binary_from_static_string(sb, s) \ + do \ + { \ + (sb)->static_data = s; \ + (sb)->size = strlen(s) + 1; \ + } \ while (0) -#define dup_into_sized_binary(sb, d, s) \ - do \ - { \ - setup_sized_binary(sb, s); \ - memcpy((sb)->data, d, s); \ - } \ +#define dup_into_sized_binary(sb, d, s) \ + do \ + { \ + size_t __size_once; \ + __size_once = s; \ + setup_sized_binary(sb, __size_once);\ + memcpy((sb)->data, d, __size_once); \ + } \ while (0) -#define exit_sized_binary(sb) \ - do \ - { \ - if ((sb)->data != NULL) \ - { \ - free((sb)->data); \ - init_sized_binary(sb); \ - } \ - } \ +#define dup_sized_binary(dst, src) \ + dup_into_sized_binary((dst), (src)->static_data, (src)->size) + + +#define exit_sized_binary(sb) \ + do \ + { \ + if ((sb)->data != NULL) \ + { \ + free((sb)->data); \ + init_sized_binary(sb); \ + } \ + } \ while (0) +#define resize_sized_binary(sb, s) \ + do \ + { \ + (sb)->size = s; \ + (sb)->data = realloc((sb)->data, \ + (sb)->size); \ + } \ + while (0) + + +#define add_to_sized_binary(sb, d, s) \ + do \ + { \ + size_t __old_size; \ + __old_size = (sb)->size; \ + (sb)->size += s; \ + (sb)->data = realloc((sb)->data, \ + (sb)->size); \ + memcpy((sb)->data + __old_size, \ + d, s); \ + } \ + while (0) + + +#define add_static_to_sized_binary(sb, d) \ + do \ + { \ + size_t __len; \ + __len = sizeof(d) - 1; \ + add_to_sized_binary(sb, d, __len); \ + } \ + while (0) + + +#define memcmp_sized_binary(s1, s2) \ + ({ \ + int __ret; \ + __ret = sort_size((s1)->size, (s2)->size); \ + if (__ret == 0) \ + __ret = memcmp((s1)->data, (s2)->data, (s1)->size); \ + __ret; \ + }) + + + +/** + * Conservations et rechargements. + */ + +#define load_sized_binary(sb, f) \ + ({ \ + uleb128_t __sz; \ + bool __ret; \ + __ret = load_uleb128(&__sz, f); \ + if (__ret) \ + { \ + setup_sized_binary(sb, __sz); \ + __ret = safe_read(f, (sb)->data, (sb)->size); \ + if (!__ret) \ + exit_sized_binary(sb); \ + } \ + __ret; \ + }) + + +#define load_sized_binary_as_string(sb, f) \ + ({ \ + uleb128_t __sz; \ + bool __ret; \ + __ret = load_uleb128(&__sz, f); \ + if (__ret) \ + { \ + setup_sized_binary(sb, __sz + 1); \ + __ret = safe_read(f, (sb)->data, __sz); \ + if (!__ret) \ + exit_sized_binary(sb); \ + (sb)->data[__sz] = '\0'; \ + } \ + __ret; \ + }) + + +#define store_sized_binary(sb, f) \ + ({ \ + bool __ret; \ + __ret = store_uleb128((const uleb128_t []){ (sb)->size }, f); \ + if (__ret) \ + __ret = safe_write(f, (sb)->static_data, (sb)->size); \ + __ret; \ + }) + + +#define store_sized_binary_as_string(sb, f) \ + ({ \ + bool __ret; \ + size_t __length; \ + assert((sb)->size >= 1); \ + __length = (sb)->size - 1; \ + assert((sb)->static_data[__length] == '\0'); \ + __ret = store_uleb128((const uleb128_t []){ __length }, f); \ + if (__ret) \ + __ret = safe_write(f, (sb)->static_data, __length); \ + __ret; \ + }) + + +#define unpack_sized_binary(sb, p, m) \ + ({ \ + uleb128_t __sz; \ + bool __ret; \ + __ret = unpack_uleb128(&__sz, p, m); \ + if (__ret) \ + { \ + setup_sized_binary(sb, __sz); \ + memcpy((sb)->data, *p, (sb)->size); \ + *((uint8_t **)p) += __sz; \ + } \ + __ret; \ + }) + + +#define unpack_sized_binary_as_string(sb, p, m) \ + ({ \ + uleb128_t __sz; \ + bool __ret; \ + __ret = unpack_uleb128(&__sz, p, m); \ + if (__ret) \ + { \ + setup_sized_binary(sb, __sz + 1); \ + memcpy((sb)->data, *p, __sz); \ + (sb)->data[__sz] = '\0'; \ + *((uint8_t **)p) += __sz; \ + } \ + __ret; \ + }) + + +#define pack_sized_binary(sb, l) \ + ({ \ + uint8_t *__result; \ + size_t __pos; \ + __result = pack_uleb128((const uleb128_t []){ (sb)->size }, l); \ + __pos = *(l); \ + *(l) += (sb)->size; \ + __result = realloc(__result, *(l) * sizeof(uint8_t)); \ + memcpy(&__result[__pos], (sb)->static_data, \ + ((sb)->size * sizeof(uint8_t))); \ + __result; \ + }) + + +#define pack_sized_binary_as_string(sb, l) \ + ({ \ + uint8_t *__result; \ + size_t __length; \ + size_t __pos; \ + assert((sb)->size >= 1); \ + __length = (sb)->size - 1; \ + assert((sb)->static_data[__length] == '\0'); \ + __result = pack_uleb128((const uleb128_t []){ __length }, l); \ + __pos = *(l); \ + *(l) += __length; \ + __result = realloc(__result, *(l) * sizeof(uint8_t)); \ + memcpy(&__result[__pos], (sb)->static_data, \ + (__length * sizeof(uint8_t))); \ + __result; \ + }) + + #endif /* _COMMON_SZBIN_H */ |