(* INCLUDE-FILE FUER ASSEMBLER *)            
(* FLORIAN MATTHES  1.6.1986   *)            
                                             
(* -------------------SCHNITTSTELLE M-CODE *)
                                             
FUNCTION ANYMODE(VAR OPC:LSTRING):TMODE;     
(* EXISTIERT DAS MNEMONIC OPC MIT EINER  *)  
(* BELIEBIGEN ADRESSIERUNGSART? DAS      *)  
(* FUNKTIONSERGEBNIS IST DIE 1. GEFUNDENE*)  
(* ADRESSIERUNGSART. (UNKNOWN, FALLS DAS *)  
(* MNEMONIC NICHT BEKANNT.               *)  
BEGIN                                        
 GLOBALOPC:= OPC;                            
 GLOBALAM := 0;      (* SUCHE BELIEBIGEN *)  
 SYS(START);                                 
 ANYMODE:= GLOBALZW;                         
END; (* ANYMODE *)                           
                                             
FUNCTION CODE(VAR OPC:LSTRING;               
                 MODE:TMODE): INTEGER;       
(* SUCHE CODE FUER MNEMONIC MIT DER       *) 
(* ANGEGEBENEN ADRESSIERUNGSART.          *) 
(* CODE=UNKNOWN, FALLS NICHT GEFUNDEN     *) 
BEGIN                                        
 GLOBALOPC:= OPC;                            
 GLOBALAM := MODE;                           
 SYS(START);                                 
 CODE:= GLOBALZW;                            
END; (* CODE *)                              
                                             
FUNCTION HBYTE(I:INTEGER):INTEGER;           
(* BERECHNE HBYTE OHNE DIVISION *)           
BEGIN                                        
 GLOBALAM:=I;                                
 HBYTE:= GLOBALHI AND 255                    
END; (* HBYTE *)                             
                                             
FUNCTION LENGTH(NUMBER:INTEGER):INTEGER;     
(* MINIMALE LAENGE IN BYTES ZUR           *) 
(* DARSTELLUNG DER ZAHL NUMBER            *) 
BEGIN                                        
 IF HBYTE(NUMBER)=0 THEN                     
   LENGTH:=1                                 
 ELSE                                        
   LENGTH:=2                                 
END;(* LENGTH *)                             
                                             
PROCEDURE WRITEADR(X:INTEGER;L: INTEGER);    
(* DRUCKE DIE VORZEICHENLOSE ADRESSE X     *)
(* X IN [0..65535]. FORMATIERUNG AUF L     *)
(* ZEICHEN LAENGE.                         *)
BEGIN                                        
  IF X>=0 THEN WRITE(X:L)                    
  ELSE WRITE(65536.0+X:L);    (* TYP REAL! *)
END; (* WRITEADR *)                          
                                             
(* ----------------------GLOBALE UTILITIES *)
                                             
PROCEDURE KEY;                               
(* WARTE IM MODUS WAIT AUF RETURN-TASTE    *)
 VAR CH: CHAR;                               
BEGIN                                        
 IF WAIT THEN                                
  BEGIN                                      
   WRITELN;                                  
   WRITELN("WEITER MIT RETURN");             
   READLN(CH);                               
  END                                        
END;(* KEY *)                                
                                             
PROCEDURE READBOOLEAN(VAR B  :BOOLEAN;       
                      DEFAULT:BOOLEAN);      
 VAR CH: CHAR;                               
BEGIN                                        
 WRITE(" (J/N): ");                          
 IF DEFAULT THEN WRITE("J?")                 
            ELSE WRITE("N?");                
 READ(CH);WRITELN;                           
 B:=(CH = "J")                               
END; (* READBOOLEAN *)                       
                                             
PROCEDURE ABORT;                             
(* FATALER FEHLER *)                         
BEGIN                                        
  GOTO 9                                     
END; (* ABORT *)                             
                                             
PROCEDURE DISK;                              
(* DISKSTATUS PRUEFEN *)                     
 VAR C1,C2:CHAR;                             
BEGIN                                        
  READ(DSKCMD,C1,C2);                        
  IF C1>="2" THEN                            
    BEGIN                                    
      WRITELN("FEHLER AUF DISKETTE:’");     
      WRITELN("NUMMER:",C1,C2);              
      WHILE NOT EOLN(DSKCMD) DO              
        BEGIN READ(DSKCMD,C1);WRITE(C1) END; 
      WRITELN; ABORT                         
    END;                                     
END;(* DISK *)                               
                                             
PROCEDURE TEXT;                              
BEGIN                                        
 WRITELN("“LFD. ZEILENNUMMER:")     
END;(* TEXT *)                               
                                             
PROCEDURE ERROR(NUMMER:INTEGER);             
  VAR I:INTEGER;                             
BEGIN                                        
  WRITE("");                               
  CASE NUMMER OF                             
   1: WRITE("SYNTAX");                       
   2: WRITE("UNDEF. LABEL");                 
   3: WRITE("ZU VIELE LABELS");              
   4: WRITE("ZERO PAGE LABEL");              
   5: WRITE("LABEL ZU LANG");                
   6: WRITE("FEHLENDER OPERAND");            
   7: WRITE("ILLEGALER OPERAND");            
   8: WRITE("FEHLENDE STARTADRESSE");        
   9: WRITE("DOPPELTES LABEL");              
  END; (* CASE *)                            
  WRITE(" FEHLER");                          
  IF ZN>=0 THEN WRITE(" IN ZEILE ",ZN);      
  WRITELN; ER:=ER+1;                         
  IF STOP THEN ABORT;                        
  KEY;IF ZN>=0 THEN TEXT                     
END;(* ERROR *)                              
                                             
PROCEDURE OUT(WERT:INTEGER);                 
(* SCHREIBE CODE AUF FILE (NUR 1 BYTE) *)    
BEGIN                                        
  AD:=ADDU(AD,1); WRITE(CODEFILE,CHR(WERT))  
END;(* OUT *)