*DECK,INIT32
          IDENT  INIT32 
          TITLE  INIT32 - CALL CODGENII 
          COMMENT  INIT32 - CALL CODGENII 
          SST 
          LIST   F
          SPACE  4
*         INIT32 - CALL CODE GENERATOR PASS 2 
          SPACE  4
          ENTRY  INIT32 
 INIT32   BSS    0
          REWIND =XF.ICF,R
  
*         THE ICF, WHICH WAS WRITTEN SEQUENTIALLY, WILL BE READ RANDOMLY
*         THUS WE MUST SET THE RANDOM ACCESS BIT. 
  
          SETRAB =XF.ICF
  
          READ   =XF.ICF     BEGIN FILLING ICFBUF 
  
          RJ     =XCODGJ1 
  
*         WE MUST CLEAR THE RANDOM ACCESS BIT BEFORE CLOSING THE ICF
*         SINCE THERE IS NO ASSOCIATED INDEX BUFFER.
  
          CLEARAB  =XF.ICF
  
          CLOSE  =XF.ICF,UNLOAD,R 
          WRITER =XF.CFL,,R 
  
          SA2    =XOPTION 
          LX4    X2 
          BX5    X2 
          LX4    59-1RR 
          LX5    59-1RX 
          BX5    X4+X5       .NOT (R OR X)
          BX3    X2 
          LX2    59-1RO 
          LX3    59-1RB 
          BX4    X2+X3
          BX4    X4+X5       NO (O OR B OR R OR X)
          NG     X4,LEAVECF 
          CLOSE  =XF.CFL,UNLOAD,R 
 LEAVECF  BSS    0
          JP     =XAFTPH32   RETURN TO PHASE30
          TITLE  BKSPIC - BACKSPACE INTERMEDIATE CODE FILE (ICF)
**        BKSPIC - BACKSPACE INTERMEDIATE CODE FILE (ICF) 
* 
*         THIS IS THE SYMPL INTERFACE ROUTINE USED TO SET THE ICF TO A
*         GIVEN WORD ADDRESS
*         THE SYMPL CALLING SEQUENCE IS-
*                XREF BKSPIC; 
*                BKSPIC (WA); 
*                WHERE- 
*                WA = WORD ADDRESS AT WHICH TO POSITION ICF 
* 
*         HENCE THE REGISTER SETUP ON ENTRY IS- 
*                A1 = FWA OF APLIST 
*                X1 = ADDRESS OF WORD CONTAINING WA 
* 
  
 BKSPIC   ENTRY. ** 
          SA2    X1          (X1) CONTAINS WORD ADDRESS 
 #RM      IFEQ   CP#RM,0
  
*         WE CALCULATE THE RSA FROM THE GIVEN WORD ADDRESS.  USING THIS 
*         RSA WE DO A READ AND BUMP OUT BY AN APPROPRIATE AMOUNT. 
  
          SX4    X2+63       WA+63
          BX7    X4 
          AX7    6           (WA+63)/64 = RSA 
          RECALL =XF.ICF
          SA7    =XF.ICF+I.RAN1 
          LX7    6           RSA*64 
          IX0    X4-X7       (WA+63)-RSA*64 = OFFSET WITHIN PRU 
  
*         CLEAR END OF RECORD BIT IN FET IN CASE IT WAS SET BY PREVIOUS 
*         CALL
  
          SB1    1
          SX6    20B
          SA3    =XF.ICF
          BX6    -X6*X3 
          SA6    A3 
  
*         SET    IN=OUT=FIRST 
  
          SA3    A3+B1       FIRST
          SX6    X3 
          SA6    A3+B1       IN 
          SA6    A6+B1       OUT
  
          READ   =XF.ICF,R
  
*         SET OUT TO FIRST + OFFSET WITHIN PRU
  
          SA4    =XF.ICF+I.FIRST
          SX4    X4 
          IX6    X4+X0
          SA6    =XF.ICF+I.OUT
 #RM      ELSE
          STORE  =XFI.ICF,WA=X2 
  
*         SET HOLDING BUFFER POINTERS TO REFLECT AN EMPTY BUFFER SO THAT
*         NEXT CALL WILL FORCE READW TO GO TO CRM 
  
          SA1    =XF.ICF+I.IN 
          BX6    X1 
          SA6    A1+1        OUT=IN 
 #RM      ENDIF 
          EQ     BKSPIC 
          TITLE  GTICF - GET FROM INTERMEDIATE CODE FILE
**        GTICF - GET FROM INTERMEDIATE CODE FILE (ICF) 
* 
*         THIS IS THE INTERFACE ROUTINE THROUGH WHICH A SYMPL PROGRAM 
*         READS FROM ICF INTO A WORKING STORAGE BUFFER. 
*         THE SYMPL CALLING SEQUENCE TO THIS ROUTINE IS-
*                XREF GTICF;
*                GTICF (BUF,NWDS,EOF);
*                WHERE- 
*                BUF = WORKING STORAGE BUFFER 
*                NWDS = NUMBER OF WORDS TO READ 
*                EOF = END OF DATA EXIT 
*         HENCE THE REGISTER SETUP ON ENTRY IS- 
*                A1 = POINTER TO APLIST 
*                X1 = FWA OF BUF
* 
  
 GTICF    ENTRY. ** 
          SA2    A1+1 
          SA0    A1          SAVE AROUND READW CALL 
          SA2    X2          NUMBER OF WORDS TO READ
          READW  =XF.ICF,X1,X2
          ZR     X1,GTICF 
  
*         END OF DATA - TAKE CALLER SPECIFIED EXIT
  
          SA4    A0+2 
          SB7    X4 
          JP     B7 
          TITLE  DB INTERFACE ROUTINE 
**
*         THIS IS A PERFORMANCE ENHANCEMENT FOR THE DEBUG COMPILER. 
* 
*         THE ROUTINE -DB- IN CODGJ1 (OLD NAME -DB-, NEW NAME -DB$-)
*         PRINTS DEBUG TRACES UNDER THE CONTROL OF THE *=H AND *=I
*         OPTIONS.  IT IS CALLED WITH A VARIABLE NUMBER OF PARAMETERS,
*         WHICH IS A CONDITION THAT SYMPL DOES NOT HANDLE GRACEFULLY. 
*         THEREFORE, CALLING -DB- PRESENTS AN INTERMINABLE OVERHEAD 
*         EVEN IF NO TRACES ARE EVER PRINTED. 
* 
*         THIS ROUTINE CHECKS THE INTERNAL OPTIONS WORD AND CALLS -DB$- 
*         ONLY IF *=H OR *=I ARE SET. 
* 
*         NOTE THAT THE APLIST POINTERS (A1/X1) MUST BE PRESERVED 
*         FOR THE CASE WHERE WE ACTUALLY CALL -DB$-.
* 
*         BELIEVE IT OR NOT, THIS INTERFACE ROUTINE SAVES AN ENORMOUS 
*         AMOUNT OF TIME OVERALL TO A COMPILATION.
  
  
.T        IFNE   TEST,0 
          ENTRY  DB 
 DB       ENTRY. ** 
          SA2    =XINTOPS    GET THE INTERNAL OPTIONS WORD
          MX3    2
          LX3    -7 
          BX3    X3*X2       ISOLATE *=I AND *=H OPTIONS
          ZR     X3,DB       RETURN IF NEITHER TRACE IS ENABLED 
  
          RJ     =XDB$       CALL -DB$- 
          EQ     DB          ...AND RETURN
  
.T        ENDIF 
  
          SPACE  4
 .T       IFNE   TEST,0 
*         TABLE USED IN PRINTING SCHEDULER HISTORY
  
          USE    SCHDBG      ENSURE LAST COMPASS BLOCK
          ENTRY  SCHDBGH
 SCHDBGH  BSS    1620 
 .T       ENDIF 
          END    INIT32 
