/*
* bitset.h -- Dynamic bitset.
*
* Copyright (c) 2001-2020, NLnet Labs. All rights reserved.
*
* See LICENSE for the license.
*
*/
#include "config.h"
#include "bitset.h"

#include <assert.h>
#include <limits.h>
#include <string.h>

size_t nsd_bitset_size(size_t bits)
{
       if(bits == 0)
               bits++;

       return (bits / CHAR_BIT) + ((bits % CHAR_BIT) != 0) + sizeof(size_t);
}

void nsd_bitset_zero(struct nsd_bitset *bset)
{
       size_t sz;

       assert(bset != NULL);

       sz = nsd_bitset_size(bset->size) - sizeof(bset->size);
       assert(sz > 0);
       memset(bset->bits, 0, sz);
}

void nsd_bitset_init(struct nsd_bitset *bset, size_t bits)
{
       assert(bset != NULL);
       if (bits == 0)
               bits++;

       bset->size = bits;
       nsd_bitset_zero(bset);
}

int nsd_bitset_isset(struct nsd_bitset *bset, size_t bit)
{
       assert(bset != NULL);
       if(bit >= bset->size)
               return 0;

       return (bset->bits[ (bit / CHAR_BIT) ] & (1 << (bit % CHAR_BIT))) != 0;
}

void nsd_bitset_set(struct nsd_bitset *bset, size_t bit)
{
       assert(bset != NULL);
       assert(bset->size > bit);
       bset->bits[ (bit / CHAR_BIT) ] |= (1 << (bit % CHAR_BIT));
}

void nsd_bitset_unset(struct nsd_bitset *bset, size_t bit)
{
       assert(bset != NULL);
       assert(bset->size > bit);
       bset->bits[ (bit / CHAR_BIT) ] &= ~(1 << (bit % CHAR_BIT));
}

void nsd_bitset_or(
       struct nsd_bitset *destset,
       struct nsd_bitset *srcset1,
       struct nsd_bitset *srcset2)
{
       size_t i, n, size, bytes;
       unsigned char bits;
       unsigned int mask;

       assert(destset != NULL);
       assert(srcset1 != NULL);
       assert(srcset2 != NULL);

       size = destset->size;
       bytes = (size / CHAR_BIT) + ((size % CHAR_BIT) != 0);

       for(i = 0; i < bytes; i++) {
               bits = 0;

               n = (srcset1->size / CHAR_BIT);
               if (n > i) {
                       bits |= srcset1->bits[i];
               } else {
                       n += ((srcset1->size % CHAR_BIT) != 0);
                       mask = (1 << ((srcset1->size % CHAR_BIT) + 1)) - 1;
                       if (n > i) {
                               bits |= (srcset1->bits[i] & mask);
                       }
               }
               n = (srcset2->size / CHAR_BIT);
               if (n > i) {
                       bits |= srcset2->bits[i];
               } else {
                       n += ((srcset2->size % CHAR_BIT) != 0);
                       mask = (1 << ((srcset2->size % CHAR_BIT) + 1)) - 1;
                       if (n > i) {
                               bits |= (srcset2->bits[i] & mask);
                       }
               }
               destset->bits[i] = bits;
       }
}