Interpreter
-----------

Wie bereits in der Einleitung erwaehnt, erzeugt in der Original-
Compiler von N.Wirth einen Bytecode, auch PCode der mittels einer
Interpreter-Routine in seinem ausgefuehrt wird.

An einem Beispiel soll der Bytecode des Original-Compilers mit
dem vom hiesigen erzeugten Assembler-Code verglichen werden.
Ausgangspunkt ist folgendes kleines PL/0-Programm:

var
 x, y;
begin
    x := 3;
    y := 3;
    x := 5 + (2 + x) * 4;
    x := 4 * (2 + x) + 5;
    y := x - y;
end.


Bytecode/PCode
--------------

Der Original-Compiler erzeugt daraus folgendes Bytecode:

0000    jmp    1   ; zur Position 0001 springen
0001    int    5   ; Platz fuer die Variablen anlegen
0002    lit    3   ; Wert 3 auf den Stack legen ...
0003    sto    3   ; ... und in der Variablen X speichern
0004    lit    3   ; Wert 3 auf den Stack legen ...
0005    sto    4   ; ... und in der Variablen Y speichern
0006    lit    5   ; Wert 5 auf den Stack legen
0007    lit    2   ; Wert 2 auf den Stack legen
0008    lod    3   ; Variable X laden
0009    opr    2   ; Addition: X + 2
0010    lit    4   ; Wert 4 auf den Stack legen
0011    opr    4   ; Multiplikation: (X + 2) * 4
0012    opr    2   ; Addition: 5 + (X + 2) * 4
0013    sto    3   ; Wert (25) in der Variablen X speichern
0014    lit    4   ; Wert 4 auf den Stack legen
0015    lit    2   ; Wert 2 auf den Stack legen
0016    lod    3   ; Variable X laden
0017    opr    2   ; Addition: (X + 2)
0018    opr    4   ; Multiplikation: 4 * (X + 2)
0019    lit    5   ; Wert 5 auf den Stack legen
0020    opr    2   : Addition: 4 * (X + 2) + 5
0021    sto    3   ; Wert (113) in der Variablen X speichern
0022    lod    3   ; Variable X laden
0023    lod    4   ; Variable Y laden
0024    opr    3   ; Substraktion: X - Y
0025    sto    4   ; Wert (110) in der Variablen Y speichern
0026    opr    0   ; Programmende (return)

Die Hauptseite enthaelt zur Veranschaulichung eine reduzierte
Version des PL/0-Interpreters fuer G-Pascal, der dieses
Beispielprogramm ausfuehrt. Bei jedem "sto"-Befehl wird
der Wert ausgegeben. Das Ergebnis ist:

start pl/0
> 3
> 3
> 25
> 113
> 110
end pl/0


Assembler-Code
--------------

Der vom hiesigen Compiler erzeugte Assembler-Code sieht
folgendermassen aus. Die Makro- und Funktionsaufrufe
folgen dem gleichen Schema wie im Original-Bytecode.
Zur Ausgabe des Ergebnisses wurde das PL/0-Programm
noch um den Befehl "write x,y;" ergaenzt. Ausgegeben
werden die Schlusswerte 113 und 110.

  +lit 3
  +sto var1
  +lit 3
  +sto var2
  +lit 5
  +lit 2
  +lod var1
  jsr add
  +lit 4
  jsr mul
  jsr add
  +sto var1
  +lit 4
  +lit 2
  +lod var1
  jsr add
  jsr mul
  +lit 5
  jsr add
  +sto var1
  +lod var1
  +lod var2
  jsr sub
  +sto var2

; write
  +lod var1
  jsr outdec
  +lit 32
  jsr outchr
  +lod var2
  jsr outdec
  +lit 13
  jsr outchr
; endwrite