(*11.3.1985                                     *)
(*DIE FOLGENDEN FUNKTIONEN COMPILIEREN EINEN    *)
(*(TEIL-)AUSDRUCK UND LIEFERN EINEN TYPINDEX    *)
FUNCTION EXPRESSION;                              
 VAR T1,T2,OPSYM,LEN1,KOMP1:INTEGER;              
                                                  
 PROCEDURE DYADIC(VAR TYP1:INTEGER;TYP2:INTEGER); 
 (*OBJEKT MIT TYP2 IST DER OBERSTE STACKEINTRAG *)
 (*OBJEKT MIT TYP1 IST DER ZWEITE  STACKEINTRAG *)
 BEGIN                                            
  IF(TYP1=REALS)OR(TYP2=REALS)THEN                
   BEGIN                                          
    TYPTEST(TYP2,REALS,129);                      
    IF TYP1<>REALS THEN                           
     BEGIN                                        
      TYPTEST(TYP1,INT,129);                      
      GEN(FLOSYM);TYP1:=REALS                     
     END                                          
   END                                            
  ELSE TYPTEST(TYP2,TYP1,129)                     
 END;(*DYADIC*)                                   
                                                  
 PROCEDURE TESTSETS(KOMP1,T2:INTEGER);            
 (*VERKNUEPFUNG DER MENGE 'SET OF KOMP1' MIT T2 *)
 (*TYP DER ERGEBNISMENGE IN TABA2[SETT]         *)
 BEGIN                                            
  IF T2<>SETT THEN ERROR(129) ELSE                
   BEGIN EXPAND(TABA2[SETT]);EXPAND(KOMP1);       
    IF KOMP1<>TABA2[SETT] THEN                    
     BEGIN (*AUSNAHME: LEERE MENGE              *)
      IF TABA2[SETT]<0 THEN TABA2[SETT]:=KOMP1    
      ELSE                                        
      IF KOMP1>=0 THEN ERROR(129)                 
     END                                          
   END                                            
 END;(*TESTSETS*)                                 
                                                  
 PROCEDURE TESTELEM(VAR ET:INTEGER);              
 (*PRUEFE ET AUF KORREKTEN TYP FUER MENGENAUFBAU*)
 (*EVTL. LAUFZEITTEST.                          *)
 BEGIN                                            
  IF ISLONG(ET) THEN ERROR(136);EXPAND(ET);       
  IF TSTFLG THEN                                  
   BEGIN GEN(TSTSYM);GENA(0);GENA(SETSIZE) END    
 END;(*TESTELEM*)                                 
                                                  
 FUNCTION SMPLEXP:INTEGER;                        
  VAR T1,T2,OPSYM,KOMP1:INTEGER;                  
                                                  
  FUNCTION TERM:INTEGER;                          
   VAR T1,T2,OPSYM,KOMP1:INTEGER;                 
                                                  
   FUNCTION FACTOR:INTEGER;                       
    VAR I:INTEGER;ART:TART;V:VARDESCRIPTOR;       
                                                  
   PROCEDURE GENSET;                              
    VAR EMPTY:BOOLEAN;X,SETTYP:INTEGER;           
   BEGIN EMPTY:=TRUE;GETSYM;                      
    IF SYM<>EKLZU THEN                            
     REPEAT                                       
      IF NOT EMPTY THEN GETSYM;                   
      X:=EXPRESSION;TESTELEM(X);                  
      IF EMPTY THEN SETTYP:=X                     
               ELSE TYPTEST(X,SETTYP,137);        
      IF SYM=174(*..*) THEN                       
       BEGIN GETSYM;X:=EXPRESSION;TESTELEM(X);    
        TYPTEST(X,SETTYP,137);GEN(GS2SYM)         
       END                                        
      ELSE GEN(GS1SYM);                           
      IF NOT EMPTY THEN GEN(UNISYM);              
      EMPTY:=FALSE                                
     UNTIL SYM<>KOMMA                             
    ELSE                                          
     BEGIN SETTYP:=-1;GEN(NULSYM) END;            
    TEST(EKLZU,12);TABA2[SETT]:=SETTYP            
   END;(*GENSET*)                                 
                                                  
   BEGIN(*FACTOR*)                                
    CASE SYM OF                                   
    IDENT:BEGIN I:=POSITION(ID);                  
           IF I<0 THEN ART:=VARBLE                
                  ELSE ART:=TABART[I];            
           CASE ART OF                            
           VARBLE,SELECT:                         
            BEGIN VARIABLE(I,V);I:=V.VTYP;        
             IF INTEST(I,FELDTYP,SEQTYP) THEN     
               GENF(V) ELSE                       
             IF I=REALS THEN GENLS(LRSYM,V) ELSE  
             IF V.ISPACKED THEN                   
               BEGIN GENF(V);GEN(LPASYM) END ELSE 
             GENLS(LSYM,V);                       
             IF(TABART[I]=FELDTYP) AND            
               (TABA3 [I]=CHART) THEN             
              BEGIN (*OBJEKT IST STRING         *)
               TABA1[STRNG]:=TABA1[I];I:=STRNG    
              END;                                
             IF TABART[I]=MENGE THEN              
              BEGIN GEN(LSASYM);                  
               TABA1[SETT]:=TABA1[I];             
               TABA2[SETT]:=TABA2[I];I:=SETT      
              END;                                
             FACTOR:=I                            
            END;                                  
           FKT:                                   
            BEGIN GETSYM;FACTOR:=CALL(I) END;     
           KONST:FACTOR:=UNSCONST(TRUE)           
           ELSE ERROR(103)                        
           END;(*CASE*)                           
          END;                                    
    KLAUF:BEGIN                                   
           GETSYM;FACTOR:=EXPRESSION;TEST(KLZU,4) 
          END;                                    
    148:  BEGIN (*NOT*)                           
           GETSYM;I:=FACTOR;                      
           IF I=BOOL THEN GEN(INVSYM)             
           ELSE                                   
            BEGIN                                 
             TYPTEST(I,INT,502);GEN(NOTSYM)       
            END;                                  
           FACTOR:=I                              
          END;                                    
    EKLAUF:BEGIN GENSET;FACTOR:=SETT END          
    ELSE(*CASE*)FACTOR:=UNSCONST(TRUE)            
    END(*CASE*)                                   
   END;(*FACTOR*)                                 
                                                  
  BEGIN(*TERM*)                                   
   T1:=FACTOR;                                    
   WHILE(SYM=STERN)OR(SYM=133)OR(SYM=QUER)        
      OR(SYM=146)  OR(SYM=128)DO                  
    BEGIN                                         
     OPSYM:=SYM;GETSYM;                           
     CASE OPSYM OF                                
     128:(*AND*)                                  
      BEGIN                                       
       IF T1<>BOOL THEN TYPTEST(T1,INT,502);      
       T2:=FACTOR;                                
       IF T2<>BOOL THEN TYPTEST(T2,INT,502);      
       IF T1<>T2 THEN ERROR(129);                 
       GENOP(OPSYM)                               
      END;                                        
     133,146:(*DIV,MOD*)                          
      BEGIN TYPTEST(T1,INT,500);T2:=FACTOR;       
       TYPTEST(T2,INT,500);GENOP(OPSYM)           
      END;                                        
     QUER:                                        
      BEGIN TYPTEST(T1,REALS,134);T2:=FACTOR;     
       TYPTEST(T2,REALS,134);GENROP(3)            
      END;                                        
     STERN:                                       
      BEGIN                                       
       IF T1=SETT THEN                            
        BEGIN KOMP1:=TABA2[SETT];T2:=FACTOR;      
         TESTSETS(KOMP1,T2);GEN(ISCSYM)           
        END                                       
       ELSE                                       
        BEGIN                                     
         IF T1<>REALS THEN TYPTEST(T1,INT,134);   
         T2:=FACTOR;DYADIC(T1,T2);                
         IF T1=REALS THEN GENROP(2)               
                     ELSE GENOP(OPSYM)            
        END                                       
      END                                         
     END(*CASE*)                                  
    END;(*WHILE*)                                 
   TERM:=T1                                       
  END;(*TERM*)                                    
                                                  
 BEGIN(*SMPLEXP*)                                 
  IF(SYM=PLUS)OR(SYM=MINUS)THEN                   
   BEGIN OPSYM:=SYM;GETSYM;T1:=TERM;              
    IF T1=REALS THEN                              
     BEGIN IF OPSYM=MINUS THEN GENROP(5) END      
    ELSE                                          
     BEGIN TYPTEST(T1,INT,105);                   
      IF OPSYM=MINUS THEN GEN(CHSSYM)             
     END                                          
   END                                            
  ELSE T1:=TERM;                                  
  WHILE(SYM=PLUS)OR(SYM=MINUS)OR(SYM=150)DO       
   BEGIN                                          
    OPSYM:=SYM;GETSYM;                            
    IF OPSYM=150(*OR*) THEN                       
     BEGIN                                        
      IF T1<>BOOL THEN TYPTEST(T1,INT,502);       
      T2:=TERM;                                   
      IF T2<>BOOL THEN TYPTEST(T2,INT,502);       
      IF T1<>T2 THEN ERROR(129);                  
      GENOP(OPSYM)                                
     END                                          
    ELSE                                          
     BEGIN                                        
      IF T1=SETT THEN                             
       BEGIN KOMP1:=TABA2[SETT];T2:=TERM;         
        TESTSETS(KOMP1,T2);                       
        IF OPSYM=PLUS THEN GEN(UNISYM)            
                      ELSE GEN(DIFSYM)            
       END                                        
      ELSE                                        
       BEGIN                                      
        IF T1<>REALS THEN TYPTEST(T1,INT,134);    
        T2:=TERM;DYADIC(T1,T2);                   
        IF T1=REALS THEN GENROP(ORD(OPSYM=MINUS)) 
                    ELSE GENOP(OPSYM)             
       END                                        
     END                                          
   END;(*WHILE*)                                  
  SMPLEXP:=T1                                     
 END;(*SMPLEXP*)                                  
                                                  
BEGIN(*EXPRESSION*)                               
 T1:=SMPLEXP;CASE SYM OF                          
 GLEICH,172,171,173,GROESSER,KLEINER:             
  BEGIN                                           
   OPSYM:=SYM;LEN1:=TABA1[T1];KOMP1:=TABA2[T1];   
   GETSYM;T2:=SMPLEXP;EXPAND(T1);EXPAND(T2);      
   CASE TABART[T1] OF                             
    STDTYP,AUFZHL:                                
      BEGIN DYADIC(T1,T2);                        
       IF T1=REALS THEN                           
        BEGIN                                     
         GEN(CMPSYM);                             
         GEN(  ORD(OPSYM=KLEINER )+               
             2*ORD(OPSYM=GLEICH  )+               
             3*ORD(OPSYM=171     )+ (*>=*)        
             4*ORD(OPSYM=GROESSER)+               
             5*ORD(OPSYM=172     )+ (*<>*)        
             6*ORD(OPSYM=173     )) (*<=*)        
        END                                       
       ELSE GENOP(OPSYM)                          
      END;                                        
    ZEIGTYP:BEGIN                                 
       IF(OPSYM<>GLEICH)AND(OPSYM<>172)           
         THEN ERROR(131);                         
       IF TABART[T2]<>ZEIGTYP THEN                
         BEGIN ERROR(129);T2:=T1 END;             
       T1:=TABA2[T1];T2:=TABA2[T2];               
       IF(T1<>T2)AND(T1>0)AND(T2>0)               
         THEN ERROR(129);(*NIL BEACHTEN!*)        
       GENOP(OPSYM);                              
      END;                                        
    FELDTYP,VERBTYP:BEGIN                         
       IF T1<>T2 THEN ERROR(129) ELSE             
       IF LEN1<>TABA1[T2] THEN ERROR(135);        
       CASE OPSYM OF                              
        GLEICH,172  :GEN(BEQSYM);                 
        173,KLEINER :GEN(BEQSYM+1);               
        GROESSER,171:GEN(BEQSYM+2);               
       END;(*CASE*)                               
       GENA(LEN1);CASE OPSYM OF                   
        172,KLEINER,171:GEN(INVSYM)               
        ELSE(*CASE LEER*)                         
        END(*CASE*)                               
      END;                                        
    MENGE:                                        
      BEGIN TESTSETS(KOMP1,T2);                   
       CASE OPSYM OF                              
        GLEICH:GEN(SEQSYM);                       
        172:BEGIN GEN(SEQSYM);GEN(INVSYM)END;     
        173:GEN(SGESYM);                          
        171:GEN(SLESYM)                           
       ELSE ERROR(132)                            
       END;(*CASE*)                               
      END                                         
    ELSE ERROR(134)                               
   END;(*CASE*)                                   
   EXPRESSION:=BOOL                               
  END;                                            
 144:(*IN*)                                       
  BEGIN TESTELEM(T1);                             
   GETSYM;T2:=SMPLEXP;IF T2<>SETT THEN ERROR(130);
   T2:=TABA2[SETT];EXPAND(T2);                    
   TYPTEST(T1,T2,134);                            
   GEN(INNSYM);EXPRESSION:=BOOL                   
  END                                             
 ELSE(*CASE*)EXPRESSION:=T1                       
 END;(*CASE*)                                     
END;(*EXPRESSION*)