(* INCLUDE-FILE FUER ASSEMBLER *)            
(* FLORIAN MATTHES 31.5.1986   *)            
                                             
(* ---------------------AUSWERTUNG FORMELN *)
                                             
PROCEDURE FORMULA(VAR WERT: INTEGER;         
                  VAR ART : TART;            
                  EVALUATE: BOOLEAN);        
(* BERECHNE FORMEL. EVALUATE=TRUE ERZWINGT *)
(* VOLLSTAENDIGE BERECHNUNG AUCH IM PASS 1 *)
                                             
  VAR NEGATIVE: BOOLEAN;                     
      WERT1   : INTEGER;                     
      ART1    : TART;                        
      OPTOKEN : TTOKEN;                      
                                             
  PROCEDURE TERM(VAR WERT: INTEGER;          
                 VAR ART :TART);             
  (* BERECHNE TERM *)                        
                                             
    PROCEDURE VALUE;                         
    (* HOLE WERT UND ART *)                  
      VAR P: TPLABEL;                        
    BEGIN                                    
      CASE TOKEN OF                          
        KONST: BEGIN                         
                 ART:= EXAKT;                
                 WERT:= GLOBALVAL; GETTOKEN  
               END;                          
        LBL  : BEGIN (* LABEL *)             
                 IF (PASS=2) OR EVALUATE THEN
                   BEGIN                     
                    P:=FIND(GLOBALLBL);      
                    IF P=NIL THEN ERROR(2);  
                    ART := EXAKT;            
                    WERT:= P^.WERT;          
                   END                       
                 ELSE                        
                   IF GLOBALLBL[1]=LESS THEN 
                     ART:= BYTE              
                   ELSE                      
                     ART:= ADDRESS;          
                 GETTOKEN;                   
               END;                          
        STAR : BEGIN                         
                 ART := EXAKT;               
                 WERT:= AD;                  
                 GETTOKEN;                   
               END;                          
        LBRACK:BEGIN                         
                GETTOKEN;                    
                FORMULA(WERT,ART,EVALUATE);  
                IF TOKEN=RBRACK THEN GETTOKEN
                ELSE ERROR(1);               
               END;                          
        ELSE   IF TOKEN<>TICK THEN ERROR(1)  
               ELSE                          
                 BEGIN (* HOCHKOMMA *)       
                   ART := EXAKT;             
                   WERT:= ORD(CH);           
                   GETCHAR;                  
                   IF CH<>TICK THEN ERROR(1);
                   GETTOKEN; GETTOKEN;       
                 END                         
      END; (* CASE *)                        
    END; (* VALUE *)                         
                                             
  BEGIN  (* TERM *)                          
   CASE TOKEN OF                             
      LSQBRACK: BEGIN GETTOKEN; VALUE;       
                  IF ART=EXAKT THEN          
                    WERT:= WERT AND 255      
                  ELSE ART:= BYTE;           
                END;                         
      RSQBRACK: BEGIN GETTOKEN; VALUE;       
                  IF ART=EXAKT THEN          
                    WERT:= HBYTE(WERT)       
                  ELSE ART:= BYTE;           
                END;                         
      TILDE   : BEGIN GETTOKEN; VALUE;       
                  IF ART=EXAKT THEN          
                    IF HBYTE(WERT)<>0 THEN   
                     WERT:=NOT(WERT)         
                    ELSE                     
                     WERT:=NOT(WERT)AND 255; 
                END;                         
      ELSE VALUE                             
     END; (* CASE *)                         
  END; (* TERM *)                            
                                             
BEGIN                                        
 WERT:=0; ART:=EXAKT;                        
 NEGATIVE:=TOKEN=MINUS;                      
 IF NEGATIVE THEN GETTOKEN;                  
 TERM(WERT,ART);                             
 IF NEGATIVE THEN                            
  BEGIN                                      
    IF ART=EXAKT THEN                        
      IF HBYTE(WERT)=0 THEN                  
        WERT:= (256-WERT) AND 255            
      ELSE                                   
        WERT:= -WERT;                        
  END;                                       
 WHILE TOKEN IN                              
   [PLUS,MINUS,ANDTOKEN,ORTOKEN] DO          
  BEGIN                                      
    OPTOKEN:= TOKEN; GETTOKEN;               
    TERM(WERT1,ART1);                        
    IF (ART1=EXAKT)AND(ART=EXAKT) THEN       
      (* WERT BERECHNEN *)                   
      CASE OPTOKEN OF                        
        PLUS    : WERT:=ADDU(WERT, WERT1);   
        MINUS   : WERT:=ADDU(WERT,-WERT1);   
        ANDTOKEN: WERT:=WERT AND WERT1;      
        ORTOKEN : WERT:=WERT OR  WERT1;      
      END                                    
    ELSE                                     
     IF (ART1=ADDRESS)OR(ART=ADDRESS)        
     THEN ART:=ADDRESS                       
     ELSE (* BYTE UND EXAKT *)               
      IF ((ART =EXAKT) AND (HBYTE(WERT )<>0))
      OR ((ART1=EXAKT) AND (HBYTE(WERT1)<>0))
      THEN ART:= ADDRESS;                    
  END; (* WHILE *)                           
END; (* FORMULA *)