Bitwise Operationen

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 BitIndex 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 Varible 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 inder 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 letzen 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))