(* INCLUDE-FILE FUER ASSEMBLER *)            
(* FLORIAN MATTHES 31.5.1986   *)            
                                             
PROCEDURE DOEQU;                             
(* KOMPLETTIERE DIE LETZTE LABELDEFINITION *)
(* IN DIESER ZEILE MIT DEM KORREKTEN WERT  *)
 VAR WERT: INTEGER;                          
     ART : TART;                             
                                             
BEGIN                                        
 GETTOKEN;                                   
 IF LASTZN<>ZN THEN ERROR(1) ELSE            
 BEGIN                                       
   FORMULA(WERT,ART,TRUE);                   
   LASTLABEL^.WERT:= WERT;                   
 END                                         
END; (* DOEQU *)                             
                                             
PROCEDURE DODFD;                             
(* DEFINIERE KONSTANTEN IM PROGRAMM        *)
(* IN PASS1 NUR LAENGE BESTIMMEN!          *)
                                             
 VAR WERT: INTEGER;                          
     ART : TART;                             
     LAST,I: INTEGER;                        
                                             
BEGIN                                        
 GETTOKEN;                                   
 WHILE TOKEN<>LINEEND DO                     
 BEGIN                                       
 IF PASS=1 THEN (* NUR AD HOCHZAEHLEN *)     
  IF TOKEN=TICK THEN                         
   BEGIN                                     
     WHILE (P<=LINELENGTH) AND (CH<>TICK) DO 
      BEGIN AD:=ADDU(AD,1); GETCHAR; END;    
     GETCHAR; GETTOKEN;                      
   END                                       
  ELSE                                       
    BEGIN                                    
     FORMULA(WERT,ART,FALSE);                
     CASE ART OF                             
      EXAKT  :AD:=ADDU(AD,LENGTH(WERT));     
      BYTE   :AD:=ADDU(AD,1);                
      ADDRESS:AD:=ADDU(AD,2);                
     END                                     
    END                                      
 ELSE    (* PASS = 2 *)                      
  IF TOKEN=TICK THEN                         
    BEGIN                                    
     WHILE (P<=LINELENGTH) AND (CH<>TICK) DO 
      BEGIN OUT(ORD(CH)); GETCHAR; END;      
     GETCHAR; GETTOKEN;                      
    END                                      
  ELSE                                       
    BEGIN  FORMULA(WERT,ART,TRUE); OUT(WERT);
     IF HBYTE(WERT)<>0 THEN OUT(HBYTE(WERT));
    END;                                     
  IF TOKEN=KOMMA THEN GETTOKEN;              
 END; (* WHILE*)                             
END;(* DODFD *)                              
                                             
PROCEDURE DOIMPORT;                          
(* IMPORTIERE GLOBALE LABELS *)              
  VAR FILENAME: FSTRING;                     
      I,WERT  : INTEGER;                     
      SYMFILE : FILE OF CHAR;                
      L       : LSTRING;                     
                                             
BEGIN                                        
  GETTOKEN;                                  
  IF TOKEN<>LBL THEN ERROR(1)                
  ELSE                                       
   BEGIN I:=1;                               
    WHILE(GLOBALLBL[I]<>" ")AND(I<=LAENGE) DO
      BEGIN                                  
        FILENAME[I]:=GLOBALLBL[I]; I:=I+1    
      END;                                   
    FILENAME[I  ]:=".";                      
    FILENAME[I+1]:="S";                      
    FILENAME[I+2]:=",";                      
    FILENAME[I+3]:="P";                      
    FILENAME[I+4]:=",";                      
    FILENAME[I+5]:="R";                      
    OPEN(SYMFILE,8,5,FILENAME); DISK;        
    REPEAT                                   
      FOR I:=1 TO LAENGE DO                  
        READ(SYMFILE,L[I]);                  
      READLN(SYMFILE,WERT);                  
      DEFINE(L,WERT);                        
    UNTIL EOF(SYMFILE);                      
    CLOSE(SYMFILE); DISK;                    
   END;                                      
END; (* DOIMPORT *)                          
                                             
PROCEDURE DOEXPORT(FILENAME: FSTRING;        
                     EXTPOS: INTEGER);       
(* EXPORTIERE LABELWERTE AUF FILE XXXXXXX.S*)
  VAR I      : INTEGER;                      
      P      : TPLABEL;                      
      FERTIG : BOOLEAN;                      
      SYMFILE: FILE OF CHAR;                 
                                             
  PROCEDURE EXPORTLABEL(P:TPLABEL);          
  (* SCHREIBE INDIZIERTES LABEL AUF SYMFILE*)
  BEGIN                                      
    WRITELN(SYMFILE,P^.NAMEN,P^.WERT:8);     
  END; (* EXPORTLABEL *)                     
                                             
  PROCEDURE PREORDER(P:TPLABEL);             
  (* AUSGABE DES LABELBAUMES IN INORDER    *)
  (* KEINE SORTIERTE AUSGABE, DA SONST     *)
  (* BAUM BEIM EINLESEN UNBALANCIERT WIRD! *)
  BEGIN                                      
    IF P<>NIL THEN                           
      BEGIN EXPORTLABEL(P);                  
       PREORDER(P^.L);PREORDER(P^.R)         
      END;                                   
  END; (* PREORDER *)                        
                                             
BEGIN                                        
  FILENAME[EXTPOS]  :="S";                   
  FILENAME[EXTPOS+4]:="W";                   
  WRITELN(DSKCMD,"S0:",FILENAME); DISK;      
  OPEN(SYMFILE,8,6,FILENAME); DISK;          
  GETTOKEN;                                  
  IF TOKEN=STAR THEN (* ALL *)               
   BEGIN PREORDER(ROOTLABEL);GETTOKEN END    
  ELSE                                       
    REPEAT                                   
      IF TOKEN<>LBL THEN ERROR(1);           
      P:= FIND(GLOBALLBL);                   
      IF P=NIL THEN ERROR(2)                 
      ELSE EXPORTLABEL(P);                   
      GETTOKEN;                              
      FERTIG:= TOKEN<>KOMMA;                 
      IF NOT FERTIG THEN                     
        BEGIN GETTOKEN;                      
          WHILE TOKEN=LINEEND DO NEWLINE;    
        END;                                 
    UNTIL FERTIG;                            
  IF TOKEN<>LINEEND THEN ERROR(1);           
  CLOSE(SYMFILE); DISK;                      
END; (* DOEXPORT *)                          
                                             
PROCEDURE INCREMENTAD;                       
(* TOKEN=OPC, GLOBALOPC ENTHAELT MNEMONIC. *)
(* GLOBALAM ENTHAELT DIE ERSTE GEFUNDENE   *)
(* ADRESSIERUNGSART.                       *)
  VAR WERT: INTEGER;                         
      ART : TART;                            
BEGIN                                        
 IF (GLOBALLBL=JMPSTR) OR (GLOBALLBL=JSRSTR) 
 THEN AD:=ADDU(AD,3)                         
 ELSE                                        
  IF GLOBALMODE=RELATIVE THEN AD:=ADDU(AD,2) 
  ELSE                                       
   BEGIN GETTOKEN;                           
     IF TOKEN=LINEEND THEN AD:=ADDU(AD,1)    
     ELSE                                    
      IF TOKEN = DBLCROSS THEN AD:=ADDU(AD,2)
      ELSE                                   
       BEGIN                                 
        FORMULA(WERT,ART,FALSE);             
        CASE ART OF                          
         EXAKT  :AD:=ADDU(AD,LENGTH(WERT)+1);
         BYTE   :AD:=ADDU(AD,2);             
         ADDRESS:AD:=ADDU(AD,3);             
        END                                  
       END;                                  
   END;                                      
 BISENDE                                     
END; (* INCREMENTAD *)