PROGRAM INF83(INPUT,OUTPUT);                                                    
TYPE TSYM=CHAR;                                       (*OPERAND ODER OPERATOR *)
     TZEIGER=^KNOTEN;                                                           
     KNOTEN=RECORD                                    (*KNOTEN DES BAUMES     *)
             S:TSYM;                                                            
             L,R:TZEIGER;                             (*OPERAND =>L,R:=NIL    *)
            END;                                      (*OPERATOR=>L,R ZEIGER  *)
VAR  W:TZEIGER;                                       (*         AUF OPERANDEN*)
                                                                                
 FUNCTION OPER(Z:TSYM):BOOLEAN;                       (*PRUEFE SYM AUF OPERAT.*)
  BEGIN                                                                         
   OPER:=(Z="+")OR(Z="-")OR(Z="*")OR(Z="/")                                     
  END;                                                                          
                                                      (*STACK SPEICHERT DIE   *)
 PROCEDURE INPUT(VAR Q:TZEIGER);                      (*ZEIGER AUF DIE NOCH   *)
 CONST MAXT=10;                                       (*NICHT VERKNUEPFTEN    *)
 VAR  SYM:TSYM;                                       (*OPERANDEN             *)
      STACK:ARRAY[0..MAXT]OF TZEIGER;                                           
      P:INTEGER;                                                                
                                                                                
 BEGIN                                                                          
  P:=0;                                               (*STACK IST LEER        *)
  READLN(SYM);                                                                  
  WHILE SYM<>"?" DO                                                             
   BEGIN NEW(Q);Q^.S:=SYM;                            (*ERZEUGE NEUEN KNOTEN  *)
    IF OPER(SYM) THEN                                                           
     BEGIN P:=P-2;Q^.L:=STACK[P];Q^.R:=STACK[P+1] END (*OPERATOR VERKNUEPFT 2 *)
                                                      (*OPERANDEN UND LIEFERT *)
                                                      (*ERGEBNIS AUF DEM STACK*)
    ELSE                                                                        
     BEGIN Q^.R:=NIL;Q^.L:=NIL               END;     (*OPERAND AUF DEM STACK *)
    STACK[P]:=Q;P:=P+1;READLN(SYM);                   (*EINTRAGEN             *)
   END;                                                                         
  WRITELN                                                                       
 END;(*INPUT*)                                                                  
                                                                                
 PROCEDURE PRINT(Q:TZEIGER;N:INTEGER);                (*DRUCKE KNOTEN Q UM N  *)
  VAR I:INTEGER;                                      (*STELLEN EINGERUECKT   *)
 BEGIN                                                                          
  IF Q<>NIL THEN                                                                
   BEGIN                                                                        
    PRINT(Q^.R,N+3);                                  (*RECHTER NACHF. ZUERST *)
    FOR I:=1 TO N DO WRITE(" ");WRITELN(Q^.S);        (*DANN DEN KNOTEN SELBST*)
    PRINT(Q^.L,N+3);                                  (*UND LINKEN NACHFOLER  *)
   END                                                                          
 END;(*PRINT*)                                                                  
                                                                                
 PROCEDURE INFIX(Q:TZEIGER;LAST:TSYM);                (*DRUCKE TERM Q. LAST   *)
  VAR SYM:TSYM;                                       (*ENTHAELT DEN LETZTEN  *)
      KLAMMER:BOOLEAN;                                (*OPERATOR.             *)
 BEGIN                                                                          
  IF Q<>NIL THEN                                                                
   BEGIN                                                                        
    SYM:=Q^.S;                                                                  
    IF OPER(SYM) THEN                                 (*OPERAND:              *)
     BEGIN                                            (*········              *)
      KLAMMER:=((LAST="/")OR(LAST="*"))AND            (*FALLS NOETIG, DEN TERM*)
               ((SYM ="+")OR(SYM ="-"));              (*KLAMMERN:             *)
      IF KLAMMER THEN WRITE("(");                                               
      INFIX(Q^.L,SYM);                                (*RECHTEN OPERANDEN     *)
      WRITE(SYM);                                     (*OPERATOR              *)
      INFIX(Q^.R,SYM);                                (*UND LINKEN OPERANDEN  *)
      IF KLAMMER THEN WRITE(")");                                               
     END                                                                        
    ELSE                                              (*OPERATOR:             *)
     WRITE(SYM);                                      (*·········             *)
                                                      (*DIREKT DRUCKEN        *)
   END                                                                          
 END;(*INFIX*)                                                                  
                                                                                
BEGIN                                                                           
 WRITELN("EINGABE DER FORMEL: (? AM ENDE)");INPUT(W);                           
 WRITELN("ERZEUGTER BAUM: (UM 90 GRAD GEDREHT)");PRINT(W,0);                    
 WRITELN("INFIXSCHREIBWEISE:");INFIX(W,"+");                                    
 WRITELN                                                                        
END.