Programmiersprache Pascal

Operatoren zur Bitmanipulation

Standard Pascal stellt keine Operatoren zur Bitmanipulation zur Verfügung.
Extended Pascal sieht sie ebenfalls nicht vor.

Viele neuere Pascal-Systeme verfügen jedoch über Operatoren zur Bitmanipulation:

  AND     bitweises AND   
  OR      bitweises OR    
  XOR     bitweises XOR (exklusives OR)
  SHL     bitweises Linksschieben (shift left)
  SHR     bitweises Rechtsschieben (shift right)
  NOT     Einerkomplement (Negation)

In der angegeben Form existieren die Operatoren z.B. in Turbo Pascal, Delphi, Pascal++.
Auch XL Pascal verfügt über die Operatoren, verwendet jedoch teilweise andere Operatorsymbole.

Bei NOT handelt es sich um einen unären Operator, alle anderen Operatoren sind binär.

Die Operatoren sind anwendbar auf Operanden mit einem Datentyp der INTEGER-Typfamilie.

Die Wirkung der Operatoren soll an einem Beispiel erläutert werden:

  VAR i, m, n : INTEGER;
  BEGIN
    i := 2; n := 1;

    m := i AND n;        { liefert m = 0
                           ein Bit von m ist genau dann auf 1 gesetzt,
                           wenn die entsprechenden Bits von i und n 
                           gleichzeitig auf 1 gesetzt sind }
    m := i OR n;         { liefert m = 3
                           ein Bit von m ist genau dann auf 1 gesetzt,
                           wenn mindestens eines der entsprechenden 
                           Bits von i und n auf 1 gesetzt ist }
    m := i XOR n;        { liefert m = 3
                           ein Bit von m ist genau dann auf 1 gesetzt,
                           wenn die entsprechenden Bits von i und n
                           verschiedene Werte besitzen }
    m := i SHL n;        { liefert m = 4
                           entspricht einer n-maligen Multiplikation
                           von i mit 2
                           m = i * 2ⁿ }
    m := i SHR n;        { liefert m = 1
                           entspricht einer n-maligen Division
                           von i durch 2 
                           m = i * 2^-n }
    m := NOT i;          { liefert m = -3
                           jedes Bit von m wird aus dem Komplement
                           des entsprechenden Bits aus i gebildet }
  END;

Beispiel:

  VAR i, n : INTEGER;

  i := 1 SHL n;          { berechnet die n-te Potenz von 2 }

Bemerkung:
Die Ausführung einer Verschiebeoperation (shift) ist im allgemeinen weniger aufwendig als die vergleichbare Multiplikation oder Division.

Anwendungsbeispiel:
Verschlüsseln und Entschlüsseln einer Zeichenkette mit Hilfe des bitweisen exklusiven Oder (XOR)

  PROGRAM geheim(OUTPUT);
  VAR str, str1, str2 : PACKED ARRAY[1..6] OF CHAR;
      code : ARRAY[1..6] OF INTEGER;
      i : INTEGER;
  BEGIN
    str := 'Geheim';                              { zu codierendes Wort }
    code[1] := 22; code[2] := 44; code[3] := 12;
    code[4] := 7;  code[5] := 33; code[6] := 96;  { Code }
  
    Writeln(str);
  
    FOR i:=1 TO 6 DO                              { codieren }
      str1[i] := Chr(Ord(str[i]) XOR code[i]);
    Writeln(str1);
  
    FOR i:=1 TO 6 DO                              { decodieren }
      str2[i] := Chr(Ord(str1[i]) XOR code[i]);
    Writeln(str2);
  END.

P. Böhme, 06.09.1996