format.h

#ifndef FORMAT_H
#define FORMAT_H

#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include "array.h"
#include "gmem.h"

typedef struct Format {
    int size;
    struct Format *list;
} Format;

// Standard array capacity for format application/extraction
#define FORMAT_BUF 4096

/* Utility formats... */
#define format_cstr \
    format_dynamic_list(char)

#define format_obj(o) \
    (Format) { \
        .size = sizeof(o), \
        .list = NULL \
    }
#define format_force(size) \
    (Format) { \
        .size = size, \
        .list = NULL \
    }
#define format_fixed_list(len_size, ...) \
    (Format) { \
        .size = len_size, \
        .list = (Format[]) { \
            __VA_ARGS__, \
            (Format) { -1 } \
        } \
    }
#define format_dynamic_list(o) \
    (Format) { \
        .size = sizeof(o), \
        .list = (void*)1 \
    }
#define format_table(...) \
    (Format[]) { \
        __VA_ARGS__, \
        (Format) { -1 } \
    }

#define format_push(arr, data, size) \
    arr = array_push(arr, data, size); \
    data += size;
#define format_retrieve(o, data, T) \
    o = *((T*)data); \
    data += sizeof(T);

/* Applies `table` to `data` and returns the resulting `char` array. */
static Array(char) format_apply(Format *table, char *data, size_t *data_passed) {

    /* Store start for `data_passed` calculation. */
    char *start = data;

    /* Initialise `char` array. */
    Array(char) buffer = array_new(0, FORMAT_BUF, sizeof(char));

    for (Format *ptr = table; ptr->size != -1; ptr++) {
        Format format = *ptr;

        if ((void*)format.list > (void*)1) {

            // (FIXED LIST)
            // Store size
            buffer = array_push(buffer, &format.size, sizeof(int));

            // Read pointer from data
            char *list = *(void**)data;

            for (int i = 0; i < format.size; i++) {
                size_t passed;
                Array(char) subbuf = format_apply(format.list, list, &passed);
                buffer = array_push(buffer, subbuf, array_len(subbuf));
                list += passed;
                array_free(subbuf);
            }

            // Skip past the pointer
            data += sizeof(void*);
        
        } else if (format.list == (void*)1) {

            // (DYNAMIC (NULL-TERMINATED) LIST)
            // Get the size of an individual element
            int element_size = format.size;

            // Create a null terminator based on size
            char *element_null = malloc(element_size);
            memset(element_null, 0, element_size);

            // Get list pointer
            char *list = *(void**)data;

            // Get the length of the list
            int list_length = 1;
            for (char *ptr = list; memcmp(ptr, element_null, element_size) != 0; ptr += element_size)
                list_length++;

            // No use!!!
            free(element_null);

            // Store the size of the list and each element
            buffer = array_push(buffer, &list_length, sizeof(int));
            for (int i = 0; i < list_length; i++) {
                buffer = array_push(buffer, list, element_size);
                list += element_size;
            }

            // Skip pointer
            data += sizeof(void*);

        } else {

            // (FIXED-SIZE OBJECT)
            // Push!
            format_push(buffer, data, format.size);

        }

    }

    if (data_passed)
        *data_passed = data - start;

    return buffer;
}

/* Prints a format completely. */
static void format_debug(Format *table, int tabc) {
    for (Format *ptr = table; ptr->size != -1; ptr++) {
        for (int i = 0; i < tabc; i++)
            printf("\t");
        if ((void*)ptr->list > (void*)1) {
            printf("fxdlist (%d):\n", ptr->size);
            format_debug(ptr->list, tabc + 1);
        } else if ((void*)ptr->list == (void*)1) {
            printf("dynlist (%d)\n", ptr->size);
        } else {
            printf("obj (%d)\n", ptr->size);
        }
    }
}

/* Extracts from `data`, allocating data for lists and whatnot. */
static Array(char) format_extract(Format *table, char *data, size_t *data_passed) {

    /* For calculating `data_passed`. */
    char *start = data;
    
    /* Initialise `extracted`. */
    Array(char) extracted = array_new(0, FORMAT_BUF, 1);

    for (Format *ptr = table; ptr->size != -1; ptr++) {
        Format format = *ptr;

        if (format.list) {

            // Get list length
            format_retrieve(
                ptr->size,
                data,
                int
            );
            format = *ptr; // And set it in the table
            int list_length = format.size;
        
            // Cheeky array for extracted data
            Array(char) extracted_list = array_new(0, FORMAT_BUF, 1);

            // Now smash the data in there
            for (int i = 0; i < list_length; i++) {
                size_t passed;
                Array(char) subext = format_extract(format.list, data, &passed);
                extracted_list = array_push(extracted_list, subext, array_len(subext));
                array_free(subext);
                data += passed;
            }

            // Don't forget to add the extracted list pointer!
            extracted_list = array_flatten(extracted_list); // Remove header and shrink
            extracted = array_push(extracted, &extracted_list, sizeof(void*));

        } else {
            
            // Simply push it
            format_push(extracted, data, format.size);

        }

    }

    if (data_passed)
        *data_passed = data - start;

    return extracted;
}

#endif