private_bitset.h

 
#ifndef CCC_PRIVATE_BITSET
#define CCC_PRIVATE_BITSET
 
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include "../types.h"
#include "configuration.h"
 
struct CCC_Bitset {
    unsigned *blocks;
    size_t count;
    size_t capacity;
};
 
enum : size_t {
    CCC_PRIVATE_BITSET_BLOCK_BITS
        = (sizeof(*(struct CCC_Bitset){}.blocks) * CHAR_BIT),
};
 
/*=========================     Private Interface   =========================*/
 
CCC_Result
CCC_private_bitset_reserve(struct CCC_Bitset *, size_t, CCC_Allocator const *);
CCC_Tribool CCC_private_bitset_set(struct CCC_Bitset *, size_t, CCC_Tribool);
 
/*================================     Macros     ===========================*/
 
#define CCC_private_bitset_block_count(private_bit_capacity)                   \
    (((private_bit_capacity) + (CCC_PRIVATE_BITSET_BLOCK_BITS - 1))            \
     / CCC_PRIVATE_BITSET_BLOCK_BITS)
 
#define CCC_private_bitset_block_bytes(private_bit_capacity)                   \
    (sizeof(*(struct CCC_Bitset){}.blocks)                                     \
     * CCC_private_bitset_block_count(private_bit_capacity))
 
#define CCC_private_bitset_default()                                           \
    (struct CCC_Bitset) {                                                      \
    }
 
#define CCC_private_bitset_non_CCC_private_bitset_default_size(                \
    private_cap, ...                                                           \
)                                                                              \
    __VA_ARGS__
#define CCC_private_bitset_default_size(private_cap, ...) private_cap
#define CCC_private_bitset_optional_size(private_cap, ...)                     \
    __VA_OPT__(CCC_private_bitset_non_)                                        \
    ##CCC_private_bitset_default_size(private_cap, __VA_ARGS__)
 
#define CCC_private_bitset_for(                                                \
    private_cap, private_count, private_bitblock_pointer                       \
)                                                                              \
    (struct CCC_Bitset) {                                                      \
        .blocks = memset(                                                      \
            (private_bitblock_pointer),                                        \
            0,                                                                 \
            CCC_private_bitset_block_bytes(private_cap)                        \
        ),                                                                     \
        .count = (private_count), .capacity = (private_cap),                   \
    }
 
#define CCC_private_bitset_from(                                               \
    private_allocator,                                                         \
    private_start_index,                                                       \
    private_count,                                                             \
    private_on_char,                                                           \
    private_string,                                                            \
    ...                                                                        \
)                                                                              \
    (struct { struct CCC_Bitset private; }){(__extension__({                   \
        struct CCC_Bitset private_bitset = CCC_private_bitset_default();       \
        size_t const private_cap                                               \
            = CCC_private_bitset_optional_size((private_count), __VA_ARGS__);  \
        size_t private_index = (private_start_index);                          \
        if (CCC_private_bitset_reserve(                                        \
                &private_bitset,                                               \
                private_cap < private_count ? private_count : private_cap,     \
                &private_allocator                                             \
            )                                                                  \
            == CCC_RESULT_OK) {                                                \
            private_bitset.count = private_count;                              \
            while (private_index < private_count                               \
                   && private_string[private_index]) {                         \
                (void)CCC_private_bitset_set(                                  \
                    &private_bitset,                                           \
                    private_index,                                             \
                    private_string[private_index] == private_on_char           \
                );                                                             \
                ++private_index;                                               \
            }                                                                  \
            private_bitset.count = private_index;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))}.private
 
#define CCC_private_bitset_with_capacity(private_allocate, private_cap, ...)   \
    (struct { struct CCC_Bitset private; }){(__extension__({                   \
        struct CCC_Bitset private_bitset = CCC_private_bitset_default();       \
        size_t const private_count                                             \
            = CCC_private_bitset_optional_size((private_cap), __VA_ARGS__);    \
        if (CCC_private_bitset_reserve(                                        \
                &private_bitset, private_cap, &private_allocate                \
            )                                                                  \
            == CCC_RESULT_OK) {                                                \
            private_bitset.count = private_count;                              \
        }                                                                      \
        private_bitset;                                                        \
    }))}.private
 
#if defined(__clang__) || defined(__llvm__)
#    define CCC_private_bitset_count_check_storage_for(                        \
        private_count,                                                         \
        private_bit_compound_literal,                                          \
        private_optional_storage_specifier...                                  \
    )                                                                          \
        (private_optional_storage_specifier struct {                           \
            static_assert(                                                     \
                sizeof(private_bit_compound_literal),                          \
                "Specify non-zero capacity of bits."                           \
            );                                                                 \
            static_assert(                                                     \
                sizeof(*(private_bit_compound_literal)) == sizeof(CCC_Bit),    \
                "CCC_bitset_storage_for and CCC_bitset_with_storage only "     \
                "accept "                                                      \
                "a (CCC_Bit[N]){} compound literal array as an argument. Do "  \
                "not "                                                         \
                "use CCC_bitset_storage_for as an argument to "                \
                "CCC_bitset_with_storage."                                     \
            );                                                                 \
            static_assert(                                                     \
                (private_count) <= sizeof(private_bit_compound_literal),       \
                "Bit count is less than or equal to capacity."                 \
            );                                                                 \
            typeof(*(struct CCC_Bitset){}.blocks) private                      \
                [CCC_private_bitset_block_count(                               \
                    sizeof(private_bit_compound_literal)                       \
                )];                                                            \
        }){}                                                                   \
            .private
 
#    define CCC_private_bitset_storage_for(                                    \
        private_bit_compound_literal, private_optional_storage_specifier...    \
    )                                                                          \
        CCC_private_bitset_count_check_storage_for(                            \
            0,                                                                 \
            private_bit_compound_literal,                                      \
            private_optional_storage_specifier                                 \
        )
 
#else
#    define CCC_private_bitset_count_check_storage_for(                        \
        private_count,                                                         \
        private_bit_compound_literal,                                          \
        private_optional_storage_specifier...                                  \
    )                                                                          \
        (typeof (                                                              \
            *(struct CCC_Bitset){}.blocks                                      \
        )[CCC_private_bitset_block_count(                                      \
            sizeof(private_bit_compound_literal)                               \
        )]) {                                                                  \
        }
 
#    define CCC_private_bitset_storage_for(                                    \
        private_bit_compound_literal, private_optional_storage_specifier...    \
    )                                                                          \
        CCC_private_bitset_count_check_storage_for(                            \
            0,                                                                 \
            private_bit_compound_literal,                                      \
            private_optional_storage_specifier                                 \
        )
#endif
 
#define CCC_private_bitset_with_storage(                                       \
    private_count,                                                             \
    private_compound_literal_array,                                            \
    private_optional_storage_specifier...                                      \
)                                                                              \
    (struct CCC_Bitset) {                                                      \
        .blocks = CCC_private_bitset_count_check_storage_for(                  \
            private_count,                                                     \
            private_compound_literal_array,                                    \
            private_optional_storage_specifier                                 \
        ),                                                                     \
        .count = (private_count),                                              \
        .capacity = CCC_private_bitset_block_count(                            \
                        sizeof(private_compound_literal_array)                 \
                    )                                                          \
                  * sizeof(*(struct CCC_Bitset){}.blocks) * CHAR_BIT,          \
    }
 
#endif /* CCC_PRIVATE_BITSET */