Bitwise Operationen

Die Bitwise Operation Bibliothek enthält ein Set aus Makrofunktionen um grundlegende Bit-Manipulationsoperationen zu machen. Sie werden von den anderen Bibliotheken benutzt und können ebenfalls überall benutzt werden. Da Makrofunktionen keinen Typ haben, sind sie mit jedem Datentyp kompatibel.

Der Bit-Index wird benutzt um einen Bit in einer Binärnummer zu spezifizieren. Indizes werden von Null an gezählt, wobei die Null den niedrigstwertigen Bit (lsb) wiedergibt. Zum Beispiel, eine 8-Bit Nummer hat 8 Bits mit Indizes von 0-7 und eine 16-Bit Nummer hat Indizes von 0-15.

• bit_mask(bit)
  

Bit index zu Bitmaske konvertieren. Parameter:

• bit - Bit index.
• Gibt Bitmaske aus.

• bit_set(value, bit)
  

Setzt ein spezifischen Bit in der Variablen. Parameter:

• value - Variable.
• bit - Bit index.

• bit_clear(value, bit)
  

Löscht ein spezifischen Bit in der Variablen. Parameter:

• value - Variable.
• bit - Bit index.

• bit_set_to(value, bit, state)
  

Setzt ein spezifischen Bit in der Variable in einen gewünschten Zustand. Parameter:

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

• bit_invert(value, bit)
  

Kehrt ein spezifischen Bit in der Variablen um . Parameter:

• value - Variable.
• bit - Bit index.

• bit_is_set(value, bit)
  

Checkt ob ein spezifischer Bit in der Variable gesetzt ist oder nicht. Parameter:

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

• bit_is_clear(value, bit)
  

Checkt ob ein spezifischer Bit in der Variablen gelöscht ist. Parameter:

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

Setzen des dritten Bits in einer 8-Bit Variablen b und invertieren des letzten Bits.

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

Das Folgende ist eine gekürzte Version des Bitweisen Operator Bibliothek Quelltextes.

//
// 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))