fixed_bitset.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _PICO_UTIL_FIXED_BITSET_H
#define _PICO_UTIL_FIXED_BITSET_H
 
#include "pico.h"

 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    uint16_t size;           
    uint16_t word_size;      
    uint32_t words[];        
} fixed_bitset_t;

#define fixed_bitset_type(N) union { \
    fixed_bitset_t bitset;      \
    struct {                    \
        uint16_t size;          \
        uint16_t word_size;     \
        uint32_t words[((N) + 31) / 32]; \
    } sized_bitset;             \
}
#define fixed_bitset_sizeof_for(N) ((((N) + 63u) / 32u) * 4u)

#define fixed_bitset_with_fill(type, N, fill) ({ type bitset; fixed_bitset_init(&bitset, type, N, fill); bitset; })
 
// Quick test that the bitset macros give the correct size
extern fixed_bitset_type(32) __not_real_bitset32;
extern fixed_bitset_type(33) __not_real_bitset33;
static_assert(sizeof(__not_real_bitset32) == fixed_bitset_sizeof_for(1),"");
static_assert(sizeof(__not_real_bitset33) == fixed_bitset_sizeof_for(37), "");
static_assert(sizeof(__not_real_bitset33) != fixed_bitset_sizeof_for(1), "");

#define fixed_bitset_init(ptr, type, N, fill) ({ \
    assert(sizeof(type) == fixed_bitset_sizeof_for(N)); \
    __unused type *type_check = ptr; \
    (ptr)->bitset.size = N; \
    (ptr)->bitset.word_size = ((N) + 31u) / 32u; \
    __builtin_memset(&(ptr)->bitset.words, (fill) ? 0xff : 0, (ptr)->bitset.word_size * sizeof(uint32_t)); \
})

static inline uint fixed_bitset_size(const fixed_bitset_t *bitset) {
    return bitset->size;
}

static inline uint fixed_bitset_word_size(const fixed_bitset_t *bitset) {
    return bitset->word_size;
}

static inline void check_fixed_bitset(__unused const fixed_bitset_t *bitset) {
    assert(bitset->word_size == (bitset->size + 31) / 32);
}

static inline fixed_bitset_t *fixed_bitset_write_word(fixed_bitset_t *bitset, uint word_num, uint32_t value) {
    check_fixed_bitset(bitset);
    if (word_num < fixed_bitset_word_size(bitset)) {
        bitset->words[word_num] = value;
    }
    return bitset;
}

static inline uint32_t fixed_bitset_read_word(const fixed_bitset_t *bitset, uint word_num) {
    check_fixed_bitset(bitset);
    if (word_num < fixed_bitset_word_size(bitset)) {
        return bitset->words[word_num];
    }
    return 0;
}

static inline fixed_bitset_t *fixed_bitset_clear_all(fixed_bitset_t *bitset) {
    check_fixed_bitset(bitset);
    __builtin_memset(bitset->words, 0, bitset->word_size * sizeof(uint32_t));
    return bitset;
}

static inline fixed_bitset_t *fixed_bitset_set_all(fixed_bitset_t *bitset) {
    check_fixed_bitset(bitset);
    __builtin_memset(bitset->words, 0xff, bitset->word_size * sizeof(uint32_t));
    return bitset;
}

fixed_bitset_t *fixed_bitset_flip_all(fixed_bitset_t *bitset);

bool fixed_bitset_is_empty(fixed_bitset_t *bitset);

static inline fixed_bitset_t *fixed_bitset_set(fixed_bitset_t *bitset, uint bit_index) {
    check_fixed_bitset(bitset);
    if (bit_index < bitset->size) {
        bitset->words[bit_index / 32u] |= 1u << (bit_index % 32u);
    }
    return bitset;
}

static inline fixed_bitset_t *fixed_bitset_clear(fixed_bitset_t *bitset, uint bit_index) {
    check_fixed_bitset(bitset);
    if (bit_index < bitset->size) {
        bitset->words[bit_index / 32u] &= ~(1u << (bit_index % 32u));
    }
    return bitset;
}

static inline fixed_bitset_t *fixed_bitset_flip(fixed_bitset_t *bitset, uint bit_index) {
    check_fixed_bitset(bitset);
    if (bit_index < bitset->size) {
        bitset->words[bit_index / 32u] ^= 1u << (bit_index % 32u);
    }
    return bitset;
}
 

static inline bool fixed_bitset_get(const fixed_bitset_t *bitset, uint bit_index) {
    check_fixed_bitset(bitset);
    assert(bit_index < bitset->size);
//    if (bit < bitset->size) {
        return bitset->words[bit_index / 32u] & (1u << (bit_index % 32u));
//    }
    return false;
}

static inline bool fixed_bitset_equal(const fixed_bitset_t *bitset1, const fixed_bitset_t *bitset2) {
    check_fixed_bitset(bitset1);
    check_fixed_bitset(bitset2);
    assert(bitset1->size == bitset2->size);
    return __builtin_memcmp(bitset1->words, bitset2->words, bitset1->word_size * sizeof(uint32_t)) == 0;
}
 
#ifdef __cplusplus
}
#endif
#endif