Bit-Operationen in AutoIt

Inhalt:

Für die folgenden 3 Bit-Operationen gilt:
Bitweiser Vergleich aller Parameter und Rückgabe je nach Funktion

BitAND ( $_param_1, $_param_2, ... )

- Positionsvergleich: Liefert 1, wenn an dieser Position in ALLEN Parametern eine 1 steht, sonst 0
- Rückgabe: Der Dualwert, der in allen Parametern vorkommt.
- Bsp.

BitAND ( 2,4,8 )   BitAND ( 2,3,6 )

       2  0010             2  0010
       4  0100             3  0011
       8  1000             6  0110
      ---------           ---------
       0  0000             2  0010

- Anwendung: z.B. Prüfen ob in einer Checksumme ein bestimmter Dual-Wert enthalten ist.
Bei der Angabe mehrerer Parameter ist das Ergebnis dann wahr, wenn ein Dualwert Bestandteil aller Parameter ist.

$CheckSum = 10
If BitAND ( $CheckSum, 2 ) Then
    MsgBox ( 0, '', '2 ist enthalten' )
Else
    MsgBox ( 0, '', '2 ist nicht enthalten' )
EndIf

[top]


BitOR ( $_param_1, $_param_2, ... )

- Positionsvergleich: Liefert 0, wenn an dieser Position in ALLEN Parametern eine 0 steht, sonst 1
- Rückgabe: Im Prinzip werden alle Parameter in Dualzahlen aufgesplittet und jede auftretende Duahlzahl wird einmalig zu einer Gesamt-Summe hinzugefügt.
- Bsp.

 BitOR ( 2,4,8 )   BitOR ( 2,3,6 )

       2  0010             2  0010
       4  0100             3  0011
       8  1000             6  0110
      ---------           ---------
      14  1110             7  0111

- Anwendung: z.B. Addition eines (od. mehrerer Werte) zu einer Checksumme.
Die Addition findet nur statt, wenn der Wert noch nicht enthalten ist.

$CheckSum = BitOR ( 8, 5 )
MsgBox ( 0, '', $CheckSum )

[top]


BitXOR ( $_param_1, $_param_2, ... )

- Positionsvergleich: Liefert 1, wenn an dieser Position eine UNGERADE Anzahl von 1 in allen Parametern steht, sonst 0
- Rückgabe: Die Summe aus dem Bitweisen Exklusiv-Oder-Vergleich.
- Bsp.

BitXOR ( 2,4,8 )   BitXOR ( 2,3,6 )

        2  0010             2  0010
        4  0100             3  0011
        8  1000             6  0110
       ---------           ---------
       14  1110             7  0111

- Anwendung: z.B. Switchen eines Wertes in einer Checksumme.
Ist in der Checksumme der Wert enthalten, wird dieser subtrahiert, sonst addiert. Die Funktion ist selbstinvers, und dadurch für alle Umkehroperationen (wie z.B. auch Verschlüsselung/Entschlüsselung) geeignet.

$x = 8
$x = BitXOR ( $x, 4 )
MsgBox ( 0, '', $x )         ; x jetzt 12
$x = BitXOR ( $x, 4 )
MsgBox ( 0, '', $x )         ; x jetzt wieder 8

[top]


Die folgenden Funktionen sind hauptsächlich für die Veränderung von Speicherwerten gedacht. Umso wichtiger ist es zu wissen, wie diese Veränderungen vorgenommen werden.

BitNOT ( $_value )

- Diese Operation wird mit 32-bit Integer Ausdrücken durchgeführt.
- Rückgabe: Gibt das Bitweise NOT des Wertes zurück.
Jede Bit-Position wird mit NOT gewandelt, aus 0 wird 1 und umgekehrt.
In 2-er Komplement Schreibweise ist das Ergebnis von BitNOT identisch mit einer Addition von 1 zum Wert und der Negation des Ergebnisses.
- Bsp.

$x = BitNot ( 5 )

 5  00000000000000000000000000000101
    --------------------------------
-6  11111111111111111111111111111010

- Hinweis
Positive Zahlen werden im Zweierkomplement mit führender 0 (Vorzeichenbit) versehen und ansonsten nicht verändert.
Negative Zahlen werden mit führender 1 als Vorzeichenbit dargestellt.
Die Darstellung negativer Zahlen im 2-er Komplement geschieht nach folgenden Regeln:
Die Ganzzahl '-6' soll dargestellt werden:

1. Dualzahl 6 darstellen:   0000000000000000000000000000110
2. alle Ziffern negieren:   1111111111111111111111111111001
3. hierzu 1 addieren:       0000000000000000000000000000001
            Übertrag:       0000000000000000000000000000010
                            -------------------------------
4. Ergebnis '-6'            1111111111111111111111111111010

[top]


BitShift ( $_param, $_shift )

- Diese Operation wird mit 32-bit Integer Ausdrücken durchgeführt.
- Führt eine Bit Shift Operation durch.
D.h., im Wert ($_param) werden die Bits um die angegebene Anzahl/Richtung ($_shift) verschoben UND dabei aus dem Speicherbereich 'herausfallende' Bits 'verfallen'.
Mit negativem $_shift wird nach links, mit positivem nach rechts verschoben.
- Bsp.

$x = BitShift ( 14, 2 )                  ; Verschiebung nach rechts

14  0000000000000000 0000000000001110
    ---------------------------------
 3  0000000000000000 0000000000000011 10 ; '10' fallen raus



$y = BitShift ( 14, -2 )                 ; Verschiebung nach links

14  0000000000000000 0000000000001110
    ---------------------------------
56  0000000000000000 0000000000111000



$z = BitShift ( 1, -31 )                 ; Verschiebung nach links

          1  0000000000000000 0000000000000001
             ---------------------------------
-2147483648  1000000000000000 0000000000000000

Der Dual-Wert entspricht 2147483645. In der Zweierkomplement-Darstellung ist das 32. Bit von rechts ein Vorzeichenbit. ( 0 = + / 1 = - ) Demzufolge ist der Ausdruck negativ.

Ein interessanter Aspekt der BitShift-Funktion ist bei einem $_shift von 1 zu erkennen:
Bei Werten >= 1 und $_shift = -1 wird der Wert verdoppelt.
Bei geradzahligen Werten > 1 und $_shift = 1 wird der Wert halbiert.
Ungeradzahlige Werte und $_shift = 1 geben den ganzzahligen Anteil des halben Wertes zurück. Vergleichbar mit Floor ( $_value/2 ).

[top]


BitRotate ( $_param, $_shift[, $_size] )

- Führt eine Bit-Shift Operation mit Wechsel durch.
D.h., im Wert ($_param) werden die Bits um die angegebene Anzahl/Richtung ($_shift ==> Standard 1) verschoben UND dabei aus dem Speicherbereich ($_size) 'herausfallende' Bits werden gewissermaßen von der entgegengesetzten Seite wieder 'eingeschoben'.
Zum besseren Verständnis müssen wir hier den Aufbau eines 32-bit Registers anschauen, als Beispiel dient das Register EAX (Extended Accumulator Register).

|--------------------------- EAX: 32bit (=1 DWORD =4 BYTES) ------------------------|
                                          |------ AX: 16bit (=1 WORD =2 BYTES) -----|
                                          |- AH:8bit (=1 BYTE)-|- AL:8bit (=1 BYTE)-|
|-----------------------------------------|--------------------|--------------------|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|XXXXXXXXXXXXXXXXXXXX|XXXXXXXXXXXXXXXXXXXX|
|-----------------------------------------|--------------------|--------------------|

AX ist der Name des "Low Word" (16bit) (niederwertiges WORD) von EAX und AL/AH (8bit) sind die "Namen" des "Low Part" (niederwertiges Byte) und "High Part" (höherwertiges Byte) von AX.
Nebenbei: 4 Bytes (das gesamte Register) sind 1 DWORD, 2 Bytes sind 1 WORD.
Ich muß also genau beachten, in welchem Bereich ich mich befinde. Dazu dient der Parameter $_size, mit den Werten 'B' (8-bit), 'W' (16-bit ==> Standard) und 'D' (32-bit).
- Bsp.

$x = BitRotate ( 7, 2 )     ; ohne Parameter 'size' ==> also 16-bit

    7  0000000000000111     ; 2 nach links (wenn Vorzeichen negativ, nach rechts)
       ----------------
   28  0000000000011100


$y = BitRotate ( 14, -2 )   ; ohne Parameter 'size' ==> also 16-bit

   14  0000000000001110     ; 2 nach rechts! (minus)
       ----------------
       0000000000000011 10  ; '10' fallen raus und werden in der Reihenfolge des Rausfallens
32771  1000000000000011     ;      von vorn angefügt


$z = BitRotate ( 14, -2, "D" )                    ; 'D' ==> 32-bit

         14  0000000000000000 0000000000001110
             ---------------------------------
             0000000000000000 0000000000000011 10 ; '10' fallen raus und werden in der
                                                  ;      Reihenfolge des Rausfallens
-2147483645  1000000000000000 0000000000000011    ;      von vorn angefügt

Der Dual-Wert entspricht 2147483645. In der Zweierkomplement-Darstellung ist das 32. Bit von rechts ein Vorzeichenbit. ( 0 = + / 1 = - ) Demzufolge ist der Ausdruck negativ.

[top]


Euer BugFix        Kontakt: Mail BugFix


Für die Codedarstellung wurde der Font Source Code Pro verwendet. Der Font steht unter der "Open Font License" (Lizenzdatei).
Der Text wurde in Quattrocento Roman verfaßt, einem ebenfalls frei verwendbaren Font.