PROGRAM PARSER(INPUT,OUTPUT);
CONST NUL=0;
      IDENTIFIER=1;
      INTEGERCONSTANT=2;
      REALCONSTANT=3;
      CHARACTER=4;
      STRING=5;

      PLUS=6;
      MINUS=7;
      TIMES=8;
      SLASH=9;
      EQUAL=10;
      NOTEQUAL=11;
      LESS=12;
      LESSOREQUAL=13;
      GREATER=14;
      GREATEROREQUAL=15;
      LPARENT=16;
      RPARENT=17;
      LBRACKET=18;
      RBRACKET=19;
      BECOMES=20;
      PERIOD=21;
      COMMA=22;
      SEMICOLON=23;
      COLON=24;
      UPTO=25;

      ANDSYM=51;
      ARRAYSYM=52;
      BEGINSYM=53;
      CASESYM=54;
      CONSTSYM=55;
      DIVSYM=56;
      DOWNTOSYM=57;
      DOSYM=58;
      ELSESYM=59;
      ENDSYM=60;
      FORSYM=61;
      FUNKTIONSYM=62;
      IFSYM=63;
      MODSYM=64;
      NILSYM=65;
      NOTSYM=66;
      OFSYM=67;
      ORSYM=68;
      OTHERSSYM=69;
      PROZEDURESYM=70;
      PROGRAMSYM=71;
      RECORDSYM=72;
      REPEATSYM=73;
      THENSYM=74;
      TOSYM=75;
      TYPESYM=76;
      UNTILSYM=77;
      VARSYM=78;
      WHILESYM=79;

      NORW = 28;
      AL = 10;
      LLENG = 120;
      EMAX = 322;
      EMIN = -292;
      INTMAX = 15;
      SMAX = 600;
      LMAX = 10;
      ERRMAX = 60;
      XMAX = 2046;
      NMAX = 1000000;
      NOS = 10;
      STACKSIZE = 2000;

      CMAX = 200;
      CZMAX = 100;
      PMAX = 200;
      PZMAX = 50;
      IMAX = 100;
      IZMAX = 50;
      TMAX = 200;
      TZMAX = 50;
      KMAX = 1000;

      GAMMA = 1;
      ZETA = 2;
      EPSILON = 3;
      MY = 4;
      TAU = 5;
      LAMBDA = 6;

TYPE SYMBOL = INTEGER;  (*WERTE DER OBEN DEF. SYMBOLE*)
     POINTER = INTEGER;
     ALFA = ARRAY[1..AL] OF CHAR;

VAR EXIT:REAL;
    SYM:SYMBOL;
    ID:ALFA;
    INUM:INTEGER;
    RNUM:REAL;
    SLENG:INTEGER;
    CH:CHAR;
    LINE: ARRAY[1..LLENG] OF CHAR;
    CC: INTEGER;
    LC: INTEGER;
    LL: INTEGER;
    ERRS: ARRAY [1..ERRMAX]  OF BOOLEAN;
    ERRPOS: INTEGER;
    WORD: ARRAY[1..NORW] OF ALFA;
    STAB: ARRAY [1..SMAX] OF CHAR;
    BOTTOM: ARRAY [1..NOS] OF POINTER;
    TOP: ARRAY [1..NOS] OF POINTER;
    STACK: ARRAY [1..STACKSIZE] OF INTEGER;

    C0,P0,I0,T0: POINTER;
    CZEIGER,PZEIGER,IZEIGER,TZEIGER: POINTER;
    CTAB: ARRAY [1..CMAX] OF INTEGER;
    CZ: ARRAY [1..CZMAX] OF POINTER;
    PTAB: ARRAY [1..PMAX] OF INTEGER;
    PZ: ARRAY [1..PZMAX] OF POINTER;
    ITAB:  ARRAY [1..IMAX] OF INTEGER;
    IZ: ARRAY [1..IZMAX] OF POINTER;
    TTAB: ARRAY [1..TMAX] OF INTEGER;
    TZ: ARRAY [1..TZMAX] OF POINTER;

    KZEIGER: POINTER;
    KITUM: ARRAY [0..TMAX,1..4] OF INTEGER;
    LZEIGER: POINTER;
    L: ARRAY [1..LMAX] OF POINTER;

PROCEDURE GETSYM;
BEGIN READ(SYM) END;

PROCEDURE ERROR;
BEGIN WRITE ("FEHLER") END;

PROCEDURE FATAL(I:INTEGER);
BEGIN WRITELN;
WRITELN("FATALER FEHLER # ",I:2);
EXIT:=1/0
END;

PROCEDURE EINKELLERN(KELLER,OBJEKT: INTEGER);
VAR K: INTEGER;
BEGIN
  TOP[KELLER]:= TOP[KELLER] + 1;
  STACK[TOP[KELLER]] := OBJEKT;
  IF TOP[KELLER] = BOTTOM[KELLER+1] THEN
  BEGIN
    FOR I:=1 TO 10 DO
    BEGIN
      BOTTOM[KELLER] := BOTTOM[KELLER] - TOP[KELLER];
      K:=K+1
    END
  END
END;

PROCEDURE AUSKELLERN(KELLER:INTEGER);
BEGIN
  TOP[KELLER] := TOP[KELLER] - 1;
  IF TOP[KELLER] < BOTTOM[KELLER] THEN FATAL
END;

PROCEDURE ERSETZEN(KELLER,OBJEKT: INTEGER);
BEGIN
  STACK[TOP[KELLER]] := OBJEKT
END;

PROCEDURE LEEREN(KELLER: INTEGER);
BEGIN
  TOP[KELLER] := BOTTOM[KELLER]
END;


PROCEDURE INITIALIZE;
VAR K,I:INTEGER;
BEGIN K:= STACKSIZE DIV NOS;
  FOR I:=2 TO NOS DO
  BEGIN TOP[I] := I*K; BOTTOM[I] := TOP[I] END;
  TOP[1]:=0; BOTTOM[1] :=0
END;

FUNCTION DD(NAME:INTEGER): BOOLEAN;
  VAR I: INTEGER;

BEGIN
  DD:=FALSE;
  FOR I:=KZEIGER-1 DOWNTO L[LZEIGER] DO
    IF NAME = KITUM[I,1] THEN DD:=TRUE
END;

PROCEDURE AUFADDIEREN(ZAHL:INTEGER; KELLER: INTEGER);
BEGIN
  STACK[TOP[KELLER]] := STACK[TOP[KELLER]] + ZAHL
END;

FUNCTION LEER(KELLER:INTEGER):BOOLEAN;
BEGIN
  LEER := TOP[KELLER] = BOTTOM[KELLER]
END;

BEGIN
EINKELLERN(10,GAMMA);
WHILE LEER(GAMMA)
DO CASE PUNKT(GAMMA)OF
   10:BEGIN
      GETSYM;
      IF SYM=LPARENT
      THEN BEGIN
           GETSYM;
           AUSDRUCK;
           WHILE SYM=COMMA
           DO BEGIN GETSYM; AUSDRUCK END;
           IF SYM<>RPARENT
           THEN ERROR
           ELSE GETSYM
           END;
      AUSKELLERN(GAMMA)
      END;
   11:BEGIN
      GETSYM;
      ERSETZEN(19,GAMMA);
      EINKELLERN(10,GAMMA)
      END;
   12:BEGIN
      GETSYM;
      AUSDRUCK;
      IF SYM<>THENSYM
      THEN ERROR
      ELSE BEGIN
           GETSYM;
           ERSETZEN(20,GAMMA);
           EINKELLERN(10,GAMMA)
           END
      END;
   13:BEGIN
      GETSYM;
      AUSDRUCK;
      IF SYM<>DOSYM
      THEN ERROR
      ELSE GETSYM
      END;
14:BEGIN
   GETSYM;
   AUSDRUCK;
   IF SYM<>OFSYM
   THEN ERROR
   ELSE BEGIN
        GETSYM;
        ERSETZEN(22,GAMMA)
        END
   END;
   15:BEGIN
      GETSYM;
      IF SYM<>IDENTIFIER
      THEN ERROR
      ELSE BEGIN
           GETSYM;
           IF SYM<>BECOMES
           THEN ERROR
           ELSE BEGIN
                GETSYM;
                AUSDRUCK;
                IF SYM<>TOSYM
                THEN IF SYM<>DOWNTOSYM
                     THEN ERROR;
                GETSYM;
                AUSDRUCK;
                IF SYM<>DOSYM
                THEN ERROR
                ELSE GETSYM
                END
           END
      END;
   17:BEGIN
      GETSYM;
      EINKELLERN(25,GAMMA)
      END;
   18:BEGIN
      GETSYM;
      ERSETZEN(25,GAMMA);
      EINKELLERN(VAR1,GAMMA)
      END;
   19:BEGIN
      GETSYM;
      ERSETZEN(26,GAMMA);
      EINKELLERN(27,GAMMA)
   END;
20:BEGIN
   IF SYM=SEMICOLON
   THEN GETSYM
  ELSE IF SYM=ENDSYM
          THEN BEGIN
               GETSYM;AUSKELLERN(GAMMA)
               END
          ELSE ERROR
   END;
21:BEGIN
   IF SYM=ELSESYM
   THEN BEGIN
        GETSYM;ERSETZEN(10,GAMMA)
        END
   ELSE AUSKELLERN(GAMMA)
   END;
22:BEGIN
    KONSTANTE;
    WHILE SYM=COMMA
    DO BEGIN GETSYM;
       KONSTANTE
       END;
    IF SYM<>COLON
    THEN ERROR
    ELSE BEGIN
         GETSYM;ERSETZEN(22,GAMMA)
         END
    END;
23:BEGIN
   IF SYM = SEMICOLON
   THEN BEGIN GETSYM;
              ERSETZEN(22,GAMMA)
        END
   ELSE IF SYM<>OTHERSSYM
        THEN IF SYM<>ENDSYM
             THEN ERROR
             ELSE AUSKELLERN(GAMMA)
        ELSE BEGIN GETSYM;
                   IF SYM<>COLON
                   THEN ERROR
                   ELSE BEGIN GETSYM;
                        ERSETZEN(24,GAMMA);
                        EINKELLERN(10,GAMMA)
                        END
            END
   END;
24:BEGIN
   IF SYM<>ENDSYM
   THEN ERROR
   ELSE BEGIN GETSYM;
              AUSKELLERN(GAMMA)
        END
   END;
25:BEGIN
   IF SYM=SEMICOLON
   THEN BEGIN GETSYM;
              EINKELLERN(10,GAMMA)
        END
   ELSE IF SYM<>UNTILSYM
        THEN ERROR
        ELSE BEGIN GETSYM;
                   AUSDRUCK;
                   AUSKELLERN(GAMMA)
             END
   END;
26:BEGIN
   IF SYM<>BECOMES
   THEN ERROR
   ELSE BEGIN GETSYM;
              AUSDRUCK;
              AUSKELLERN(GAMMA)
        END
   END 
END