BeRTOS
bitarray.h
Go to the documentation of this file.
00001 
00039 #ifndef STRUCT_BITARRAY_H
00040 #define STRUCT_BITARRAY_H
00041 
00042 #include <cfg/compiler.h>
00043 #include <cfg/macros.h>
00044 #include <cfg/debug.h>
00045 
00046 #include <cpu/types.h>
00047 
00048 typedef struct BitArray
00049 {
00050     size_t size;          
00051     size_t bitarray_len;  
00052     uint8_t *array;       
00053 } BitArray;
00054 
00061 #define BITARRAY_ALLOC(name, size)   uint8_t name[DIV_ROUNDUP((size), 8)]
00062 
00068 INLINE void bitarray_set(BitArray *bitx, int idx)
00069 {
00070     ASSERT((size_t)idx <= bitx->bitarray_len);
00071 
00072     int page = idx / 8;
00073     uint8_t bit = idx % 8;
00074 
00075     bitx->array[page] |= BV(bit);
00076 }
00077 
00083 INLINE void bitarray_clear(BitArray *bitx, int idx)
00084 {
00085     ASSERT((size_t)idx <= bitx->bitarray_len);
00086 
00087     int page = idx / 8;
00088     uint8_t bit = idx % 8;
00089 
00090     bitx->array[page] &= ~BV(bit);
00091 }
00092 
00102 INLINE void bitarray_setRange(BitArray *bitx, int idx, int offset)
00103 {
00104     ASSERT((size_t)idx <= bitx->bitarray_len);
00105 
00106     for (int i = idx; i < offset + idx; i++)
00107         bitarray_set(bitx, i);
00108 }
00109 
00119 INLINE void bitarray_clearRange(BitArray *bitx, int idx, int offset)
00120 {
00121     ASSERT((size_t)idx <= bitx->bitarray_len);
00122 
00123     for (int i = idx; i < offset + idx; i++)
00124         bitarray_clear(bitx, i);
00125 }
00126 
00134 INLINE bool bitarray_test(BitArray *bitx, int idx)
00135 {
00136     ASSERT((size_t)idx <= bitx->bitarray_len);
00137     int page = idx / 8;
00138     uint8_t bit = idx % 8;
00139 
00140     return (bitx->array[page] & BV(bit));
00141 }
00142 
00151 INLINE bool bitarray_isFull(BitArray *bitx)
00152 {
00153     // test full bytes except the last one
00154     for (size_t page = 0; page <= bitx->size - 2; page++)
00155     {
00156         if (!(bitx->array[page] == 0xff))
00157             return 0;
00158     }
00159     // test the last byte using the correct bitmask
00160     uint8_t mask = BV(bitx->bitarray_len >> 3) - 1;
00161     if (!(bitx->array[bitx->size - 1] & mask))
00162         return 0;
00163 
00164     return 1;
00165 }
00166 
00167 /*
00168  * Ugly!.. reformat it.
00169  */
00178 INLINE bool bitarray_isRangeFull(BitArray *bitx, int idx, int offset)
00179 {
00180     ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);
00181 
00182     for (int i = idx; i <= idx + offset; i++)
00183         if (!bitarray_test(bitx, i))
00184             return 0;
00185 
00186     return 1;
00187 }
00188 
00189 /*
00190  * Ugly!.. reformat it.
00191  */
00200 INLINE bool bitarray_isRangeEmpty(BitArray *bitx, int idx, int offset)
00201 {
00202     ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);
00203 
00204     for (int i = idx; i <= idx + offset; i++)
00205         if (bitarray_test(bitx, i))
00206             return 0;
00207 
00208     return 1;
00209 }
00210 
00217 INLINE void bitarray_dump(BitArray *bitx)
00218 {
00219     kprintf("bitarray size[%zu]bits on [%zu]bytes\n", bitx->bitarray_len, bitx->size);
00220 
00221     int i = 0;
00222     int j = 0;
00223     int count = bitx->bitarray_len;
00224 
00225     while (count--)
00226     {
00227         kprintf("%d", bitarray_test(bitx, i++));
00228         if (j == 7)
00229         {
00230             kprintf("..%02x [%d]\n", bitx->array[(i / 8) - 1], i);
00231             j = 0;
00232             continue;
00233         }
00234         j++;
00235     }
00236 
00237     if (j != 0)
00238         kprintf("..%02x [%d]\n", bitx->array[i / 8], i);
00239 }
00240 
00257 INLINE void bitarray_init(BitArray *bitx, size_t bitarray_len, uint8_t *array, size_t size)
00258 {
00259     bitx->size = size;
00260     bitx->array = array;
00261     bitx->bitarray_len = bitarray_len;
00262 }
00263 
00264 
00265 int bitarray_testSetup(void);
00266 int bitarray_testRun(void);
00267 int bitarray_testTearDown(void);
00268 
00269 #endif /* STRUCT_BITARRAY_H */