Bit-Operationen in AutoIt

    Inhalt:


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

   
BitAND ( param1, param2,... )

        - 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 ( param1, param2,... )

        - 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 ( param1, param2,... )

        - 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 ( value, shift )

        - Diese Operation wird mit 32-bit Integer Ausdrücken durchgeführt.
        - Führt eine Bit Shift Operation durch.
          D.h., im Wert (value) 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'-Wert 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 ( Wert / 2 ).
    
top


   
BitRotate ( value , shift [, size] )

        - Führt eine Bit-Shift Operation mit Wechsel durch.
          D.h., im Wert (value) 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