bitarray.h

Go to the documentation of this file.

#ifndef STRUCT_BITARRAY_H
#define STRUCT_BITARRAY_H

#include <cfg/compiler.h>
#include <cfg/macros.h>
#include <cfg/debug.h>

#include <cpu/types.h>

typedef struct BitArray
{
    size_t size;          
    size_t bitarray_len;  
    uint8_t *array;       
} BitArray;

#define BITARRAY_ALLOC(name, size)   uint8_t name[DIV_ROUNDUP((size), 8)]

INLINE void bitarray_set(BitArray *bitx, int idx)
{
    ASSERT((size_t)idx <= bitx->bitarray_len);

    int page = idx / 8;
    uint8_t bit = idx % 8;

    bitx->array[page] |= BV(bit);
}

INLINE void bitarray_clear(BitArray *bitx, int idx)
{
    ASSERT((size_t)idx <= bitx->bitarray_len);

    int page = idx / 8;
    uint8_t bit = idx % 8;

    bitx->array[page] &= ~BV(bit);
}

INLINE void bitarray_setRange(BitArray *bitx, int idx, int offset)
{
    ASSERT((size_t)idx <= bitx->bitarray_len);

    for (int i = idx; i < offset + idx; i++)
        bitarray_set(bitx, i);
}

INLINE void bitarray_clearRange(BitArray *bitx, int idx, int offset)
{
    ASSERT((size_t)idx <= bitx->bitarray_len);

    for (int i = idx; i < offset + idx; i++)
        bitarray_clear(bitx, i);
}

INLINE bool bitarray_test(BitArray *bitx, int idx)
{
    ASSERT((size_t)idx <= bitx->bitarray_len);
    int page = idx / 8;
    uint8_t bit = idx % 8;

    return (bitx->array[page] & BV(bit));
}

INLINE bool bitarray_isFull(BitArray *bitx)
{
    // test full bytes except the last one
    for (size_t page = 0; page <= bitx->size - 2; page++)
    {
        if (!(bitx->array[page] == 0xff))
            return 0;
    }
    // test the last byte using the correct bitmask
    uint8_t mask = BV(bitx->bitarray_len >> 3) - 1;
    if (!(bitx->array[bitx->size - 1] & mask))
        return 0;

    return 1;
}

/*
 * Ugly!.. reformat it.
 */
INLINE bool bitarray_isRangeFull(BitArray *bitx, int idx, int offset)
{
    ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);

    for (int i = idx; i <= idx + offset; i++)
        if (!bitarray_test(bitx, i))
            return 0;

    return 1;
}

/*
 * Ugly!.. reformat it.
 */
INLINE bool bitarray_isRangeEmpty(BitArray *bitx, int idx, int offset)
{
    ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);

    for (int i = idx; i <= idx + offset; i++)
        if (bitarray_test(bitx, i))
            return 0;

    return 1;
}

INLINE void bitarray_dump(BitArray *bitx)
{
    kprintf("bitarray size[%zu]bits on [%zu]bytes\n", bitx->bitarray_len, bitx->size);

    int i = 0;
    int j = 0;
    int count = bitx->bitarray_len;

    while (count--)
    {
        kprintf("%d", bitarray_test(bitx, i++));
        if (j == 7)
        {
            kprintf("..%02x [%d]\n", bitx->array[(i / 8) - 1], i);
            j = 0;
            continue;
        }
        j++;
    }

    if (j != 0)
        kprintf("..%02x [%d]\n", bitx->array[i / 8], i);
}

INLINE void bitarray_init(BitArray *bitx, size_t bitarray_len, uint8_t *array, size_t size)
{
    bitx->size = size;
    bitx->array = array;
    bitx->bitarray_len = bitarray_len;
}


int bitarray_testSetup(void);
int bitarray_testRun(void);
int bitarray_testTearDown(void);

#endif /* STRUCT_BITARRAY_H */