PROGRAM PARSER(INPUT,OUTPUT);      (*VERSION 12-DEC-80*)
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;
      NORI = 8;
      AL = 10;
      LLENG = 120;
      EMAX = 322;
      EMIN = -292;
      INTMAX = 15;
      SMAX = 600;
      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;
      NCMAX = 100;

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

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

VAR SYM: SYMBOL;
    VORSYM: SYMBOL;
    ID: ALFA;
    INUM: INTEGER;
    RNUM: REAL;
    CH: CHAR;
    LINE: ARRAY[1..LLENG] OF CHAR;
    CC: INTEGER;
    LC: INTEGER;
    LOC: INTEGER;
    LL: INTEGER;
    ERRS: ARRAY [1..ERRMAX,1..3] OF INTEGER;
    ERRCOUNT: INTEGER;
    WORD: ARRAY[1..NORW] OF ALFA;
    STAB: ARRAY [1..SMAX] OF CHAR;
    STRINGS: ARRAY [1..LLENG] OF CHAR;
    SLENG: INTEGER;
    BOTTOM: ARRAY [0..NOS] OF POINTER;
    TOP: ARRAY [0..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 [1..KMAX,1..4] OF INTEGER;
    NZEIGER: POINTER;
    NIDEK: ARRAY [1..NCMAX,1..2] OF INTEGER;

PROCEDURE LIESWORD(I:INTEGER);
  VAR J:INTEGER;
BEGIN
  FOR J:=1 TO AL DO READ(WORD[I,J])
END;

PROCEDURE SCHREIB(OBJEKT:ALFA);
  VAR I: INTEGER;
BEGIN
  FOR I:=1 TO AL DO WRITE(OBJEKT[I]);
  WRITELN
END;

PROCEDURE ERRMESSAGE;
  VAR I: INTEGER;
BEGIN
  IF ERRCOUNT > 0 THEN
  BEGIN
  FOR I := 1 TO ERRCOUNT DO
  WRITELN("ERROR # ",ERRS[I,1]:3," AT ",ERRS[I,2],",",ERRS[I,3]);
  HALT
  END
END;

PROCEDURE GETSYM;
BEGIN READLN(SYM); WRITELN;
  IF SYM < 100 THEN SCHREIB(WORD[SYM])
  ELSE WRITELN("IDENTIFIER # ",(SYM-100):3)
END;

PROCEDURE FATAL(I:INTEGER);
BEGIN WRITELN;
  WRITELN("FATALER FEHLER # ",I:2);
  ERRMESSAGE;
  HALT
END;

PROCEDURE ERROR;
BEGIN
  WRITE ("FEHLER");
  ERRCOUNT:=ERRCOUNT+1;
  IF ERRCOUNT>ERRMAX THEN FATAL(1)
  ELSE 
  BEGIN
    ERRS[ERRCOUNT,1] := 1;
    ERRS[ERRCOUNT,2] := LC;
    ERRS[ERRCOUNT,3] := LOC;
  END
END;

PROCEDURE EINKELLERN(OBJEKT,KELLER: INTEGER);
  VAR I,K: INTEGER;
BEGIN
  TOP[KELLER]:= TOP[KELLER] + 1;
  STACK[TOP[KELLER]] := OBJEKT;
  IF TOP[KELLER] = BOTTOM[KELLER+1] THEN FATAL(0)
END;

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

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

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

PROCEDURE ENTER(NAME,KENNNR,X1,X2: INTEGER);
BEGIN
  KITUM[KZEIGER,1] := NAME;
  KITUM[KZEIGER,2] := KENNNR;
  KITUM[KZEIGER,3] := X1;
  KITUM[KZEIGER,4] := X2;
  KZEIGER := KZEIGER +1;
  IF KZEIGER > KMAX THEN FATAL(1)
END;

FUNCTION PUNKT(KELLER: INTEGER): INTEGER;
BEGIN
  PUNKT := STACK[TOP[KELLER]]
END;

FUNCTION DD(NAME:INTEGER): BOOLEAN;
  VAR I: INTEGER;
BEGIN
  DD:=FALSE;
  FOR I:=KZEIGER-1 DOWNTO PUNKT(0) 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;

FUNCTION NPUNKT(KELLER,N: INTEGER): INTEGER;
BEGIN
  IF TOP[KELLER] - N < BOTTOM[KELLER] THEN FATAL(0)
  ELSE NPUNKT := STACK[TOP[KELLER]-N+1]
END;

PROCEDURE NEWLEVEL;
BEGIN
  EINKELLERN(KZEIGER,0)
END;

PROCEDURE OUTLEVEL;
BEGIN
  KZEIGER := TOP[0];
  AUSKELLERN(0)
END;

FUNCTION INKITUM(NAME:INTEGER): INTEGER;
  VAR I: INTEGER;
BEGIN
  I := KZEIGER - 1;
  WHILE (I>0) AND (KITUM[I,1] <> NAME) DO I:=I-1;
  INKITUM := I
END;

PROCEDURE INITIALIZE;
  VAR K,I,X1,X2,N:INTEGER;
BEGIN K:= STACKSIZE DIV (NOS + 1);
  FOR I:=0 TO NOS DO
  BEGIN TOP[I] := I*K; BOTTOM[I] := TOP[I] END;
  FOR I := 1 TO NORI DO
  BEGIN
    READ(N,K,X1,X2);
    ENTER(N,K,X1,X2)
  END;
  FOR I:=1 TO NORW DO LIESWORD(I)
END;