diff options
Diffstat (limited to 'src/common/szbin.h')
| -rw-r--r-- | src/common/szbin.h | 129 | 
1 files changed, 102 insertions, 27 deletions
| diff --git a/src/common/szbin.h b/src/common/szbin.h index ac938ab..5891449 100644 --- a/src/common/szbin.h +++ b/src/common/szbin.h @@ -29,6 +29,12 @@  #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 +44,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 +54,110 @@ 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;                 \ -    }                                   \ +#define setup_sized_binary(sb, s)           \ +    do                                      \ +    {                                       \ +        (sb)->data = malloc(s);             \ +        (sb)->size = s;                     \ +    }                                       \      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                                      \ +    {                                       \ +        setup_sized_binary(sb, s);          \ +        memcpy((sb)->data, d, s);           \ +    }                                       \      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 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;                                                  \ +        size_t __n;                                                 \ +        __n = (s1)->size < (s2)->size ? (s1)->size : (s2)->size;    \ +        __ret = memcmp((s1)->data, (s2)->data, __n);                \ +        if (__ret == 0)                                             \ +            __ret = sort_unsigned_long_long((s1)->size, (s2)->size);\ +        __ret;                                                      \ +    }) + + +#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 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;                                                          \ +    }) + +  #endif  /* _COMMON_SZBIN_H */ | 
