Load and store various values.

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