Opérations bit à bit

La librairie des opérations bit à bit contient un ensemble de fonctions qui permettent de réaliser les opérations de manipulation des bits classiques. Elles sont utilisées dans les autres fonctions de la librairie et peuvent l'être n'importe où. Comme les fonctions macros non pas de type, elles sont compatibles avec tous les types de données.

L'index du bit est utilisé pour spécifier le bit dans un nombre binaire. Les indexes débutent à partir de zéro, où zéro représente le plus petit bit significatif (LSB). Par exemple, un nombre de 8-bits a 8 bits indexés de 0 à 7 alors qu'un nombre de 16-bits est indexé de 0 à 15.

• bit_mask(bit)
  

Bit index to bit mask converting. Parameters:

• bit - Bit index.
• Returns bit mask.

• bit_set(value, bit)
  

Sets a specified bit in the variable. Parameters:

• value - Variable.
• bit - Bit index.

• bit_clear(value, bit)
  

Clears a specified bit in the variable. Parameters:

• value - Variable.
• bit - Bit index.

• bit_set_to(value, bit, state)
  

Set a specified bit in the variable to desired state. Parameters:

• value - Variable.
• bit - Bit index.
• state - State (true or false).

• bit_invert(value, bit)
  

Inverts a specified bit in the variable. Parameters:

• value - Variable.
• bit - Bit index.

• bit_is_set(value, bit)
  

Checks whether a specified bit in the variable is set or not. Parameters:

• value - Variable.
• bit - Bit index.
• Returns boolean value true when bit is set and false when bit is cleared.

• bit_is_clear(value, bit)
  

Checks whether a specified bit in the variable is cleared or not. Parameters:

• value - Variable.
• bit - Bit index.
• Returns boolean value true when bit is cleared and false when bit is set.

Setting up a third bit in the 8-bit variable b and inverting of the last one.

#include <homelab/bit.h>
 
int main(void)
{
	unsigned char b = 0x00;
 
	bit_set(b, 2);
	bit_invert(b, 7);
}

The following is a shortened version of the bitwise operations library source code.

//
// Functions for handling bits.
//
#define bit_mask(bit)            (1 << (bit))
#define bit_set(value, bit)      value |= bit_mask(bit)
#define bit_clear(value, bit)    value &= ~bit_mask(bit)
#define bit_invert(value, bit)   value ^= bit_mask(bit)
#define bit_is_set(value, bit)   ((value) & (bit_mask(bit)))
#define bit_is_clear(value, bit) (!((value) & (bit_mask(bit))))
#define bit_set_to(v, b, x) v = ((x) ? (v | bit_mask(b)) : (v & ~bit_mask(b)))
 
//
// Functions for handling bit masks.
//
#define bitmask_set(value, bitMask)     value |= (bitMask)
#define bitmask_clear(value, bitMask)   value &= ~(bitMask)
#define bitmask_invert(value, bitMask)  value ^= (bitMask)
#define bitmask_set_to(v, m, x)         v = ((x) ? (v | (m)) : (v & ~(m))) 
#define bitmask_is_set(value, bitMask)  ((value) & (bitMask))