path: root/src/common/szbin.h

/* Chrysalide - Outil d'analyse de fichiers binaires
 * szbin.h - prototypes pour une manipulation de données accompagnées d'une taille
 *
 * Copyright (C) 2024 Cyrille Bagard
 *
 *  This file is part of Chrysalide.
 *
 *  Chrysalide is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Chrysalide is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef _COMMON_SZBIN_H
#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
{
    union {

        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       */

} sized_binary_t;


#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_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                                      \
    {                                       \
        size_t __size_once;                 \
        __size_once = s;                    \
        setup_sized_binary(sb, __size_once);\
        memcpy((sb)->data, d, __size_once); \
    }                                       \
    while (0)


#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;                                                  \
        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;                                                      \
    })



/**
 * 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 */