(*==============================================*)
(*  9.9.1986                                    *)
(* U1: 30.6.1989                                *)
(* INCLUDE-FILE "P.CALL1.P"                     *)
(*==============================================*)
                                                  
FUNCTION CALL (I:INTEGER):INTEGER;                
(* PROZEDUR-/FUNKTIONSAUFRUF COMPILIEREN. FALLS *)
(* FUNKTIONSAUFRUF, WIRD ERGEBNIS IM STANDARD-  *)
(* FORMAT AUF DEM STACK HINTERLASSEN. I ZEIGT   *)
(* DANN AUF ZUGEHOERIGEN TYPEINTRAG.            *)
 VAR J,K,TYPFORM: INTEGER;                        
     NPAR       : INTEGER;                        
     OLD        : BOOLEAN; (* U1: *)              
     V          : VARDESCRIPTOR;                  
                                                  
 PROCEDURE GETVARADR(VAR V:VARDESCRIPTOR);        
 (* LADE ADRESSE DER VARIABLEN AUF DEN STACK *)   
 BEGIN                                            
  IF SYM<>IDENT THEN ERROR(154);                  
  VARIABLE(POSITION(ID),V); GENF(V)               
 END; (* GETVARADR *)                             
                                                  
 FUNCTION STD (I:INTEGER):INTEGER;                
 (* STANDARD-PROZEDUR/FUNKTION AUFRUFEN. TYP-   *)
 (* INDEX BEI FUNKTIONEN ZURUECKLIEFERN         *)
 CONST                                            
  ABISYM= 48; INTSYM= 51;COPYSYM= 68; LENSYM= 69; 
  POSSYM= 70; INSSYM= 71; DELSYM= 72; POKSYM= 94; 
  PEKSYM= 95;                                     
  OPNSYM= 96; CLSSYM= 97; SICSYM= 98; SOCSYM= 99; 
  CLRSYM=100; PUTSYM=101; GTSYM =102; RDCSYM=103; 
  RDISYM=104; RDRSYM=105; RDSSYM=106; RDLSYM=107; 
  WRCSYM=108; WRISYM=109; WRRSYM=110; WRSSYM=111; 
  WRBSYM=112; WRLSYM=113; KEYSYM=114; HBYSYM=115; 
  STRSYM=118; VALSYM=119; TRCSYM=120;SLOWSYM=121; 
 FASTSYM=122; RNDSYM=123;                         
  AKTSYM=125; IFKSYM=126; EXTSYM=127;             
  LOCEXT= 6;         (* EXTENDED CODES (LOCATE) *)
                                                  
  VAR X,FIND :INTEGER;                            
      PARAMS :SET OF INTEGER;                     
       (* FIND WIRD VON FADR (GLOBAL) AUF DEN   *)
       (* LAUFENDEN FILETYP GESETZT             *)
                                                  
  PROCEDURE INTEXP;                               
  (* AUSDRUCK VOM TYP INTEGER KOMPILIEREN       *)
   VAR T:INTEGER;                                 
  BEGIN                                           
   T:=EXPRESSION; TYPTEST(T,INT,142)              
  END; (* INTEXP *)                               
                                                  
  PROCEDURE CHKKOM;                               
  (* PRUEFE AUF KOMMA, ')' NICHT UEBERLESEN     *)
  BEGIN                                           
    IF SYM=KOMMA THEN GETSYM ELSE                 
    IF SYM<>KLZU THEN TEST(KOMMA,22)              
    ELSE ERROR(22);                               
  END; (* CHKKOM *)                               
                                                  
  PROCEDURE CHKSEP;                               
  (* PRUEFE AUF KOMMA ODER ')' FUER DEFAULTPARM.*)
  BEGIN                                           
   IF SYM=KOMMA THEN GETSYM ELSE                  
   IF SYM<>KLZU THEN TEST(KOMMA,22);              
  END; (* CHKSEP *)                               
                                                  
  PROCEDURE DEFAULTEXP(X:INTEGER);                
  (* INTEGERAUSDRUCK LESEN, BZW. DEFAULTWERT    *)
  (* X AUF DEN STACK, FALLS KOMMA ODER ')'      *)
  (* AUSSERDEM AUF SEPARATOR TESTEN             *)
  BEGIN                                           
   IF (SYM=KOMMA) OR (SYM=KLZU) THEN GENLDC(X)    
   ELSE INTEXP;                                   
   CHKSEP;                                        
  END; (* DEFAULTEXP *)                           
                                                  
  PROCEDURE GETXY;                                
  (* X/Y-KOORDINATEN KOMPILIEREN. SPAETER AUCH  *)
  (* POLARKOORDINATEN UND SKALIERUNG            *)
  BEGIN                                           
   INTEXP; CHKKOM; INTEXP                         
  END; (* GETXY *)                                
                                                  
  PROCEDURE GETDEFXY;                             
  (* X/Y-KOORDINATEN KOMPILIEREN. EVTL. LETZTE  *)
  (* PICELCURSORPOSITION LADEN:                 *)
  BEGIN                                           
   IF (SYM=KOMMA) OR (SYM=KLZU) THEN GEN(AKTSYM)  
   ELSE GETXY                                     
  END; (* GETDEFXY *)                             
                                                  
  PROCEDURE STREXP;                               
  (* BELIEBIGEN STRINGAUSDRUCK KOMPILIEREN      *)
   VAR T:INTEGER;                                 
  BEGIN                                           
   T:=EXPRESSION; MAKESTRING(T);                  
  END; (* STREXP *)                               
                                                  
  PROCEDURE RW (ISLN,ISREAD: BOOLEAN);            
   LABEL 7;                                       
   VAR FIRST,NOPAR:BOOLEAN;                       
       X          :INTEGER;                       
                                                  
   PROCEDURE DEFLT;                               
   (* FILE INPUT ODER OUTPUT ALS DEFAULT        *)
   BEGIN                                          
    IF ISREAD THEN                                
     BEGIN                                        
      GENLDC(TABA1[ INFILE]); GEN(SICSYM)         
     END                                          
    ELSE                                          
     BEGIN                                        
      GENLDC(TABA1[OUTFILE]); GEN(SOCSYM)         
     END                                          
   END; (* DEFLT *)                               
                                                  
   PROCEDURE CHECKF;                              
   (* TESTET X AUF FILEBEZEICNER UND CODIERT    *)
   (* DANN ENTSPRECHENDE SIC/SOC SEQUENZ.       *)
   (* AUSSERDEM TYPANPASSUNG X (GLOBAL!)        *)
   BEGIN                                          
    IF TABART[ZU.VTYP]=AUSSCH                     
           THEN X:=TABA2[ZU.VTYP]                 
           ELSE X:=ZU.VTYP;                       
    IF FIRST THEN                                 
     BEGIN FIRST:=FALSE;                          
      IF TABART[X]=SEQTYP THEN                    
       BEGIN (* DESCRIPTOR-ADR. SCHON AUF STACK *)
        IF TABA2[X]<>CHART THEN ERROR(173);       
        IF ISREAD THEN GEN(SICSYM)                
                  ELSE GEN(SOCSYM);               
        GOTO 7                                    
       END                                        
      ELSE DEFLT                                  
     END                                          
   END; (* CHECKF *)                              
                                                  
  BEGIN (* RW *)                                  
   NOPAR:=TRUE; FIRST:=TRUE;                      
   IF SYM<>KLAUF THEN DEFLT                       
   ELSE                                           
    BEGIN GETSYM;            (* PARAMETER LESEN *)
     REPEAT                                       
      IF ISREAD THEN                              
       BEGIN                                      
        IF SYM<>IDENT THEN ERROR(154);            
        ZUW1(POSITION(ID)); CHECKF;               
        CASE X OF                                 
         INT   :GEN(RDISYM);                      
         CHART :GEN(RDCSYM);                      
         REALS :GEN(RDRSYM)                       
         ELSE                                     
          BEGIN                                   
           IF TABART[X]<>STRTYP THEN ERROR(116);  
           GEN(RDSSYM)                            
          END                                     
        END; (* CASE *)                           
        ZUW2(X);       (* TEST BEI AUSSCH/STRNG *)
       END                                        
      ELSE                                        
       BEGIN (* WRITE *)                          
        ZU.VTYP:=EXPRESSION; CHECKF;              
        (* UMWANDLUNG, BEVOR (!) LAENGE GELESEN *)
        IF NOT (X IN [BOOL,CHART,INT,REALS]) THEN 
         BEGIN MAKESTRING(X); X:=STRNG END;       
        IF SYM=DPKT THEN BEGIN GETSYM; INTEXP END 
        ELSE GENLDC(0);                           
        IF X=REALS THEN                           
         IF SYM=DPKT THEN BEGIN GETSYM; INTEXP END
         ELSE GENLDC(-8);                         
        CASE X OF                                 
         CHART:GEN(WRCSYM);                       
         INT  :GEN(WRISYM);                       
         STRNG:GEN(WRSSYM);                       
         REALS:GEN(WRRSYM);                       
         BOOL :GEN(WRBSYM)                        
        END; (* CASE *)                           
       END; (* WRITE *)                           
      NOPAR:=FALSE;                               
      7:X:=SYM; GETSYM                            
     UNTIL X<>KOMMA;                              
     IF X<>KLZU THEN ERROR(4)                     
    END;                                          
   IF NOPAR AND NOT ISLN THEN ERROR(172);         
   IF ISLN THEN                                   
    IF ISREAD THEN GEN(RDLSYM)                    
              ELSE GEN(WRLSYM);                   
   GEN(CLRSYM)                                    
  END; (* RW *)                                   
                                                  
  PROCEDURE FADR;                                 
  (* FILEBEZEICHNER LESEN UND ADRESSE DES FILE- *)
  (* DESCRIPTORS KOMPILIEREN. (FIND -> FILETYP) *)
   VAR V:VARDESCRIPTOR;                           
  BEGIN                                           
   IF SYM<>IDENT THEN                             
    BEGIN ERROR(2); FIND:=INFILE END              
   ELSE FIND:=POSITION(ID);                       
   VARIABLE(FIND,V); GENF(V); FIND:=V.VTYP;       
   IF TABART [FIND]<>SEQTYP THEN                  
    BEGIN ERROR(171); FIND:=TXTF END;             
  END; (* FADR *)                                 
                                                  
  PROCEDURE FOPER (DIFF:INTEGER);                 
  (* FUER EOF/EOLN/STATUS: ADRESSE COMPILIEREN  *)
  (*  ##### KANN VERAENDERT WERDEN (BOOLEAN!)   *)
   VAR V:VARDESCRIPTOR;                           
  BEGIN                                           
   IF SYM=KLAUF THEN                              
    BEGIN                                         
     GETSYM;FADR;TEST(KLZU,4);                    
     IF DIFF<>0 THEN                              
      BEGIN GENLDC(DIFF);GEN(ADUSYM) END          
    END                                           
   ELSE                                           
    BEGIN                                         
     FIND:=TXTF;GENLDC(TABA1[INFILE]+DIFF)        
    END;                                          
   V.ACCESS:=ABSOLUTE;GENLS(LSYM,V)               
  END; (* FOPER *)                                
                                                  
  PROCEDURE GENGRF;                               
  (* AUFRUF EINER GRAFIKROUTINE KOMPILIEREN     *)
  (* UMWANDLUNG I (GLOBAL!) IN FUNKTIONSCODE    *)
  BEGIN                                           
   GEN(EXTSYM); GEN(I-GRAFIK);                    
  END; (* GENGRF *)