(****************************************************************************)
(*                       Baum- und Listenoperationen                        *)
(****************************************************************************)

PROCEDURE LoescheListe(VAR L : RefListe);
  VAR p : RefListe;
  BEGIN
    WHILE L<>NIL DO
     BEGIN
       p:=L^.naechster; freemem(L,SIzeOf(RefListe)+succ(length(L^.Name))); L:=p
     END
  END; (* LoescheListe *)

PROCEDURE Einfuegen(VAR B : Baum; VAR Bez : str127; Ref : RefListe);
  LABEL EXIT;
  VAR p,q : Baum;
      Richtung : (l,r);
  BEGIN
    p:=B; q:=p;
    WHILE p<>NIL DO WITH p^ DO BEGIN
      q:=p;
      IF Bez<Name THEN BEGIN p:=links; Richtung:=l END ELSE
      IF Bez>Name THEN BEGIN p:=rechts; Richtung:=r END
      ELSE GOTO EXIT
      END;
    getmem(p,3*SizeOf(Baum)+succ(length(Bez)));
    WITH p^ DO BEGIN links:=NIL; rechts:=NIL; von:=Ref; Name:=Bez END;
    IF q<>NIL THEN IF Richtung=l THEN q^.links:=p ELSE q^.rechts:=p ELSE B:=p;
    EXIT:
  END; (* Einfuegen *)

PROCEDURE suche(B : Baum; VAR Bez : str127; VAR gef : Baum);
  VAR Erfolg : boolean;
  BEGIN
    gef:=B; Erfolg:=false;
    WHILE (gef<>NIL) AND (NOT Erfolg) DO WITH gef^ DO
      IF Bez<Name THEN gef:=links ELSE
      IF Bez>Name THEN gef:=rechts
      ELSE Erfolg:=true
  END; (* suche *)

(*$A-*)  (* Die rekursiven Ganz-Baum-Operationen *)
PROCEDURE LoeschBaum(VAR B : Baum; LokalTest : boolean);

  PROCEDURE CheckVon(L : RefListe; B : Baum);
    VAR p,q : RefListe;
    BEGIN
      p:=L; IF p<>NIL THEN WHILE p^.naechster<>NIL DO p:=p^.naechster;
      IF p=NIL
        THEN Einfuegen(LokalListe,B^.Name,NIL)
        ELSE IF p^.Name<>ProzListe[V].Name
          THEN BEGIN
                  IF p^.Name=B^.Name THEN p^.Name:=''; (* Direkte Rekursion *)
                  getmem(q,SizeOf(RefListe)+succ(length(p^.Name)));
                  q^.Name:=p^.Name; q^.naechster:= NIL;
                  Einfuegen(LokalListe,B^.Name,q)
               END
    END; (* CheckVon *)

  BEGIN (* LoeschBaum *)
    IF B<>NIL THEN WITH B^ DO
      BEGIN
        LoeschBaum(links,LokalTest); LoeschBaum(rechts,LokalTest);
        IF LokalTest THEN CheckVon(von,B);
        LoescheListe(von);
        freemem(B,3*SizeOf(Baum)+succ(length(Name))); B:=NIL;
      END
  END; (* LoeschBaum *)

PROCEDURE SchreibListe(B : Baum);
 BEGIN
   IF B<>NIL THEN WITH B^ DO
     BEGIN
       SchreibListe(links);
       IF von=NIL THEN print('  '+Name+'  ()')
                  ELSE print('  '+Name+'  ('+von^.Name+')');
       SchreibListe(rechts)
     END
  END; (* SchreibListe *)
(*$A+*)

(****************************************************************************)
(*                       Stack-Operationen                                  *)
(****************************************************************************)

PROCEDURE Push(VAR S : ProgStack; W : CheckedWords);
  BEGIN WITH S DO BEGIN Ptr:=succ(Ptr); Stack[Ptr]:=W END END;

PROCEDURE Pop(VAR S : ProgStack; VAR W : CheckedWords);
  BEGIN WITH S DO IF Ptr>0 THEN BEGIN W:=Stack[Ptr]; Ptr:=pred(Ptr) END END;

FUNCTION Leer(VAR S : ProgStack) : boolean;
  BEGIN Leer:=S.Ptr=0 END;

PROCEDURE NeuStack(VAR S : ProgStack);
  BEGIN S.Ptr:=0 END;