bitfield.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015 INRIA
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once

 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include "irq.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define BITFIELD(NAME, SIZE)  uint8_t NAME[((SIZE) + 7) / 8]

static inline void bf_set(uint8_t field[], size_t idx)
{
    field[idx / 8] |= (1u << (7 - (idx % 8)));
}

static inline void bf_set_atomic(uint8_t field[], size_t idx)
{
    unsigned state = irq_disable();
    bf_set(field, idx);
    irq_restore(state);
}

static inline void bf_unset(uint8_t field[], size_t idx)
{
    field[idx / 8] &= ~(1u << (7 - (idx % 8)));
}

static inline void bf_unset_atomic(uint8_t field[], size_t idx)
{
    unsigned state = irq_disable();
    bf_unset(field, idx);
    irq_restore(state);
}

static inline void bf_toggle(uint8_t field[], size_t idx)
{
    field[idx / 8] ^= (1u << (7 - (idx % 8)));
}

static inline void bf_toggle_atomic(uint8_t field[], size_t idx)
{
    unsigned state = irq_disable();
    bf_toggle(field, idx);
    irq_restore(state);
}

static inline bool bf_isset(const uint8_t field[], size_t idx)
{
    return (field[idx / 8] & (1u << (7 - (idx % 8))));
}

static inline void bf_or(uint8_t out[], const uint8_t a[], const uint8_t b[], size_t len)
{
    len = (len + 7) / 8;
    while (len--) {
        out[len] = a[len] | b[len];
    }
}

static inline void bf_or_atomic(uint8_t out[], const uint8_t a[],
                                const uint8_t b[], size_t len)
{
    unsigned state = irq_disable();
    bf_or(out, a, b, len);
    irq_restore(state);
}

static inline void bf_and(uint8_t out[], const uint8_t a[], const uint8_t b[], size_t len)
{
    len = (len + 7) / 8;
    while (len--) {
        out[len] = a[len] & b[len];
    }
}

static inline void bf_and_atomic(uint8_t out[], const uint8_t a[],
                                 const uint8_t b[], size_t len)
{
    unsigned state = irq_disable();
    bf_and(out, a, b, len);
    irq_restore(state);
}

static inline void bf_xor(uint8_t out[], const uint8_t a[], const uint8_t b[], size_t len)
{
    len = (len + 7) / 8;
    while (len--) {
        out[len] = a[len] ^ b[len];
    }
}

static inline void bf_xor_atomic(uint8_t out[], const uint8_t a[],
                                 const uint8_t b[], size_t len)
{
    unsigned state = irq_disable();
    bf_xor(out, a, b, len);
    irq_restore(state);
}

static inline void bf_inv(uint8_t out[], const uint8_t a[], size_t len)
{
    len = (len + 7) / 8;
    while (len--) {
        out[len] = ~a[len];
    }
}

static inline void bf_inv_atomic(uint8_t out[], const uint8_t a[], size_t len)
{
    unsigned state = irq_disable();
    bf_inv(out, a, len);
    irq_restore(state);
}

int bf_get_unset(uint8_t field[], size_t len);

int bf_find_first_set(const uint8_t field[], size_t size);

int bf_find_first_unset(const uint8_t field[], size_t size);

void bf_set_all(uint8_t field[], size_t size);

static inline void bf_set_all_atomic(uint8_t field[], size_t size)
{
    unsigned state = irq_disable();
    bf_set_all(field, size);
    irq_restore(state);
}

void bf_clear_all(uint8_t field[], size_t size);

static inline void bf_clear_all_atomic(uint8_t field[], size_t size)
{
    unsigned state = irq_disable();
    bf_clear_all(field, size);
    irq_restore(state);
}

unsigned bf_popcnt(const uint8_t field[], size_t size);
 
#ifdef __cplusplus
}
#endif