/* 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 <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 dup_into_sized_binary(sb, d, s)     \
    do                                      \
    {                                       \
        setup_sized_binary(sb, s);          \
        memcpy((sb)->data, d, s);           \
    }                                       \
    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 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 */