*DECK S$GNGR1 
          IDENT  S$GNGR1
          TITLE  S$GNGR1 -  GENERATE- GET-USER-RECORD, CASE 1 
          COMMENT  GEN- GET-USER-RECORD, CASE 1 
          B1=1               FOR (GENMAC (GET)) 
  
*CALL LBLPTR
  
          SPACE  4
**        S$GNGR1 -  GENERATE- GET-USER-RECORD, CASE 1
* 
*     CALLING SEQUENCE- 
*         S$GNGR1(SPEC$OWN1, SPEC$OWN2, OREC, MAX-WORD-LEN, 
*                 NFILES, FITARRAY, SPEC$FASTIN,
*                 SPEC$OWNT,SPEC$VERIFY); 
* 
*     GIVEN-
*         SPEC$OWN1 = 0 OR ADDRESS OF OWN1 PROCEDURE
*         SPEC$OWN2 = 0 OR ADDRESS OF OWN2 PROCEDURE
*         OREC = WORD OFFSET FROM WSA$ TO FIRST WORD FOR EXTERNAL REC 
*         MAX-WORD-LEN = MAXIMUM WORD LENGTH OF AN EXTERNAL RECORD
*         NFILES = NUMBER OF INPUT FILES
*         FITARRAY = ARRAY OF ADDRESSES OF FIT-S
*         SPEC$FASTIN > 0 IF FAST I/O IS TO BE DONE AND ALL INPUT 
*                         FILES ARE BT=C, RT=F, FL=SPEC$FASTIN
*                     < 0 IF FAST I/O IS TO BE DONE AND ALL INPUT 
*                         FILES ARE BT=I, RT=W, MRL=-SPEC$FASTIN
*                     = 0 IF FAST I/O IS NOT TO BE DONE 
*         SPEC$OWNT = TRUE OF SM5 STYLE INTERFACE 
*                     FALSE IF SM4 STYLE INTERFACE. 
* 
*     GENERATES-  "GETREC":  TRY TO GET USER RECORD.
*                            IF NONE, 
*                                SET REGISTER = END-OF-DATA 
*                                GO TO "GOTIREC". 
*                            SETS WSAS$OREC = USER-RECORD.
  
  
          ENTRY  S$GNGR1
 S$GNGR1  SUBR
  
          SB1    1           CONSTANT 1 
  
*     PUT RELEVANT PARAMETERS IN REGISTERS
  
  
          SA0    A1          SAVE ACTUAL PARAMETER LIST FOR LATER USE 
  
          SA2    X1          VALUE OF SPEC$OWN1 
          SB2    X2          ZERO OR ADDRESS OF OWN1 PROCEDURE
          SA2    A1+B1       ADDRESS OF SPEC$OWN2 
          SA2    X2          VALUE OF SPEC$OWN2 
          SB3    X2          ZERO OR ADDRESS OF OWN2 PROCEDURE
          SA2    A1+2        ADDRESS OF WSAS$OREC 
          SA2    X2          VALUE OF WSAS$OREC 
          SB4    X2          B4 = VALUE OF WSAS$OREC
          SA2    A1+4        ADDRESS OF <NO OF INPUT FILES> 
          SA2    X2          VALUE OF NO OF INPUT FILES 
          SB5    X2          B5 = NO OF INPUT FILES 
          SA2    A1+6        ADDRESS OF SPEC$FASTIN 
          SA2    X2          VALUE OF SPEC$FASTIN 
          BX6    X2 
          SA6    FASTIO      FASTIO = SPEC$FASTIN 
          NEWLBL ORECLEN
          NEWLBL SRECLEN
          NEWLBL LRECLEN
  
  
  
*     GENERATE-   "GETREC":  GO TO "ENTRY<N>" ACCORDING TO
*                             "GETENTRY" (ORIGINALLY "ENTRY0")
  
          GENLBL GETREC 
          NEWLBL GETENTRY 
          GEN    (SA1 "GETENTRY") 
  
          IFTHEN B2=0        IF NO OWN1 PROCEDURE 
            NEWLBL ENTRY3 
            GEN    (NZ X1,"ENTRY3")    *NON-ZERO MEANS ENTRY3 
          ELSE- 
            NEWLBL LABEL1 
            GEN    (ZR X1,"LABEL1")    *IF GETENTRY =0 OR -0
            GEN    (SX1 X1-1)          *TEST GETENTRY FOR 1 
  
            NEWLBL ENTRY1 
            GEN    (ZR X1,"ENTRY1")    *GETENTRY=1 MEANS ENTRY1 
  
            NEWLBL ENTRY3 
            GEN    (EQ "ENTRY3")     *NON-ZERO AND NOT 1 MEANS ENTRY3 
  
            GENLBL LABEL1 
            ENDIF.
  
          IFTHEN B3"0        IF OWN2 PROCEDURE
            NEWLBL ENTRY2 
            GEN    (NG X1,"ENTRY2")    *MINUS ZERO MEANS "ENTRY2" 
            ENDIF.
  
*     GENERATE-              SET WSA$+OREC = EXTERNAL RECORD FROM FILE
*                            SET "ORECLEN" = LENGTH OF RECORD (CHARACTERS)
*                            IF END-OF-FILE, GO TO "EOF"
  
          SA1    FASTIO 
          IFTHEN X1"0        IF FAST I/O WANTED,
            CALL   GETFAST     GET RECORD VIA FAST CIO CALLS
          ELSE-              IF RECORD MANAGER WANTED,
            CALL   GETRM       GET RECORD VIA RECORD MANAGER
            ENDIF.
  
*         INCREMENT THE ELEMENT OF S$ARRY WHICH HOLDS THE COUNT OF
*         THE NUMBER OF RECORDS READ FROM INPUT 
            GEN    (SA2 S$ARRY)        * ADDRESS OF STAT.ARRAY
            GEN    (SX6 B1) 
            GEN    (IX6 X2+X6)         *INCREMENT NO. OF RECORDS READ 
            GEN    (SA6 A2)            * PUT INTO STAT. ARRAY 
  
          NEWLBL GRILBL1
  
* GENERATE RUNTIME ERROR - VARIABLE RECORD TOO SHORT
  
          NEWLBL NEXT 
          GEN    (EQ "NEXT")
          NEWLBL ERROR4 
          NEWLBL ERROR156 
          NEWLBL ERRORZ 
          GENLBL ERROR4 
          GEN    (PS) 
          GEN    (PS "ERROR156")
          GENLBL ERRORZ 
          GENMAC (DATA 0) 
          GENMAC (DATA 0)     TERMINATOR
          GENLBL ERROR156 
          GENMAC (DATA 156) 
  
          GENLBL NEXT 
  
          SB7    B2+B3       B7<>0 IF OWN1 OR OWN2 SPECIFIED
          IFTHEN B7"0        IF OWN1 OR OWN2
            NEWLBL NEXT 
            GEN    (EQ "NEXT")
  
  
            GENLBL APLIST                *APLIST
            GEN    (PS) 
            NEWLBL RTNCODE
            GEN    (PS "RTNCODE")        *ADDR OF RETURN CODE NRA 
            GENMAC (DATA 0)              *ADDR OF WSA$OREC
            GEN    (PS) 
            GEN    (PS "ORECLEN") 
            GENMAC (DATA 0) 
            GENLBL RTNCODE               *FTN RETURN CODE NRA 
            GENMAC (DATA 0) 
  
            GENLBL ERROR1 
            GEN    (PS) 
            NEWLBL ERROR152 
            GEN    (PS "ERROR152")
            GENMAC (DATA 0)            *ZERO TERMINATOR 
  
            GENLBL ERROR2 
            GEN    (PS) 
            NEWLBL ERROR154 
            GEN    (PS "ERROR154")
            GENMAC (DATA 0)            *ZERO TERMINATOR 
  
            GENLBL ERROR3 
            GEN    (PS) 
            NEWLBL ERROR155 
            GEN    (PS "ERROR155")
            GENMAC (DATA 0)              *ZERO TERMINATOR 
  
            GENLBL ERROR0 
            GEN    (PS) 
            GEN    (PS 1+"ERROR1")         *ZERO WORD PARAMETER 
            GENMAC (DATA 0)                *ZERO TERMINATOR 
  
            GENLBL ERROR152              *RETURN FROM FTN4 W/O SMRTN
            GENMAC (DATA 152)            * (E$152)
  
            GENLBL ERROR154              *CALLING SMRTN FROM FTN5 
            GENMAC (DATA 154)            * (E$154)
  
            GENLBL ERROR155              *NRA NOT IN RANGE 0-3
            GENMAC (DATA 155) 
  
            GENLBL NEXT 
            ENDIF.
  
* 
*     GENERATE-          ( IF SPEC$OWN1 NQ 0 )
* 
*                 "ENTRY1":    SET UP APLIST WITH WSAS$OREC 
*                                AND RECORD LENGTH FROM CRM.
*                              CALL OWNCODE1. 
*                              TEST NRA TO DETERMINE ACTION NEEDED
*                              IF ACTION IS DELETE, 
*                                  GO BACK TO "GETREC". 
*                              IF ACTION IS SUBSTITUTE, 
*                                  MOVE OWNCODE1 RECORD TO WSAS$OREC. 
*                              IF ACTION IS TERMINATE,
*                                  GOTO OWNCODE2 OR SORT. 
*                              IF ACTION IS INSERT, 
*                                  SAVE OWNCODE RECORD AT "SAVEREC" 
*                                  TO BE COPIED TO WSAS$OREC NEXT TIME. 
*                              IN EACH CASE,"GETENTRY" IS SET PROPERLY
*                                  SO WE KNOW WHERE TO ENTER NEXT TIME. 
* 
  
  
          IFTHEN B2"0        IF OWN1 PROCEDURE SPECIFIED
  
            NEWLBL NEXT 
            GEN    (EQ "NEXT")
  
            GENLBL ENTRY1 
  
* 
* MOVE RECORD AT SAVEREC TO OREC
* 
            NEWLBL SAVEREC
            GEN    (SA2 "SAVEREC")
  
            GEN    (SB2 10)              *NO CHAR/WORD
            GEN    (SA5 "SRECLEN")
            GEN    (BX6 X5) 
            GEN    (SA6 "ORECLEN")
          GEN    (SB3 X5)              *RECORD LENGTH 
            GEN    (SA5 "WSA")
            GEN    (SX5 X5+0),B4         *SX5 WSA+OREC
  
            GENLBL GRILOOP1 
            GEN    (BX6 X2) 
            GEN    (SA6 X5)              *COPY TO 1ST WORD OF WSAS$OREC 
          GEN    (SA2 A2+B1)           *GET NEXT WORD FROM SAVEREC AREA 
            GEN    (SX5 X5+B1)
            GEN    (SB3 B3-B2)           *DECREMENT CHAR COUNT
            GEN    (LT B0,B3,"GRILOOP1") *IF MORE WORDS TO MOVE 
  
            GENLBL NEXT 
            GEN    (SA5 "WSA")
            GEN    (SX6 X5+0),B4         *SX6 WSA+OREC
            GEN    (SA6 B1+"APLIST")     *SET WSAS$OREC AT APLIST+1 
  
            SA4    A0+7        ADDRESS OF SPEC$OWNT 
            SA4    X4          VALUE OF SPEC$OWNT 
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
              GEN    (SA1 "APLIST")      *APLIST = NRA,RECADDR,RECLEN 
              GEN    (MX6 0)
              GEN    (SA6 X1)            *ZERO OUT RETURN CODE NRA
            ELSE- 
              GEN    (SA1 A6)            *APLIST = RECADDR,RECLEN 
              ENDIF.
  
  
            NEWLBL NEXT 
            GEN    (SX6 "NEXT")          *RETURN ADDR FROM SMRTN
            GEN    (SA6 S$RTNAD)
            GEN    (RJ 0),B2             *RJ OWNCODE1 
            GEN    (SB0 0)
  
* 
* USER GOT HERE WITH NORMAL RETURN, ONLY OK WITH FTN5 INTERFACE 
* 
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
              GEN    (SA1 "APLIST")        *USE SAME APLIST FOR FTN5
              NEWLBL LABEL4 
              GEN    (EQ "LABEL4")
            ELSE- 
  
              GEN    (SA1 "ERROR1") 
              GEN    (RJ =XS$ERROR)      *CALL ERROR ROUTINE
            GEN    (SA1 "ERROR0")      *ZERO TO PRINT ERROR 
            GEN    (RJ =XS$ERROR) 
              GEN    (RJ =XS$ABT)           *CALL SORT5 ABORT ROUTINE 
  
            ENDIF.
  
  
            GENLBL NEXT                  *RETURN HERE FROM SMRTN
  
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
            GEN    (SA1 "ERROR2") 
              GEN    (RJ =XS$ERROR)      *CALL ERROR ROUTINE
            GEN    (SA1 "ERROR0")      *ZERO TO PRINT ERROR 
            GEN    (RJ =XS$ERROR) 
              GEN    (RJ =XS$ABT)        *SORT5 ABORT ROUTINE 
  
              GENLBL LABEL4 
              ENDIF.
  
            GEN    (SB1 1)               *CONSTANT 1
                                         * A1 SET TO APLIST ABOVE FOR FTN5
                                         * OR SET IN FTN4 PROGRAM 
            GEN    (SA2 X1)              *X2 = NRA
            NEWLBL NEXT 
            GEN    (PL X2,"NEXT")        *IF NRA IS POSITIVE
  
            GEN    (SA1 "ERROR3")         * E$155 
            GEN    (RJ =XS$ERROR) 
            GEN    (SA1 "ERROR0")      * ZERO TO PRINT ERROR
            GEN    (RJ =XS$ERROR) 
            GEN    (RJ =XS$ABT)          *SORT5 ABORT ROUTINE 
  
            GENLBL NEXT 
            NEWLBL NEXT 
            GEN    (SX0 X2-4) 
            GEN    (MI X0,"NEXT")        *IF NRA LE 3 
  
            GEN    (SA1 "ERROR3")         * E$155 
            GEN    (RJ =XS$ERROR) 
            GEN    (SA1 "ERROR0")      * ZERO TO PRINT ERROR
            GEN    (RJ =XS$ERROR) 
            GEN    (RJ =XS$ABT)          *SORT5 ABORT ROUTINE 
  
            GENLBL NEXT 
            GEN    (SX0 X2) 
            GEN    (SB5 X0-1)            *TEST FOR DELETE 
  
*         INCREMENT THE ELEMENT OF S$ARRY WHICH HOLDS THE COUNT OF
*         THE NUMBER OF RECORDS DELETED BY OWN1 
            NEWLBL NEXT 
            GEN    (NE B5,"NEXT") 
            GEN    (SA2 S$ARRY+1)      *GET COUNT OF REC.S DELETED
            GEN    (SX7 B1) 
            GEN    (IX7 X2+X7)         *INCREMENT COUNT FOR OWN1
            GEN    (SA7 A2)            *UPDATE COUNT
            GEN    (EQ "GETREC")       *GO BACK FOR NEW REC.
  
            GENLBL NEXT 
            GEN    (SB5 X0-3)            *TEST FOR TERMINATE
            GEN    (EQ B5,"GRILBL1")     *IF NRA=3(TERMINATE) 
  
            GEN    (SA2 A1+B1)           *ADDR OF OUTARR1 
            GEN    (SA2 X2)              *VALUE OF OUTARR1
            GEN    (SA3 A1+2)            *ADDR OF OUTRL1
            GEN    (SA3 X3)              *VALUE OF OUTRL1 
  
            GEN    (SB5 X0-2)            *TEST FOR INSERT 
            NEWLBL LABEL2 
            GEN    (EQ B5,"LABEL2") 
  
                                         *SUBSTITUTE RECORD 
  
* 
* SUBSTITUTE OREC WITH RECORD AT ADDR OUTARR1 ( LENGTH IN OUTRL1 )
* 
            GEN    (SA5 "WSA")
            GEN    (SX5 X5+0),B4         *SX5 WSA+OREC ADDR 
  
            GEN    (BX6 X3)              *OUTRL1
            GEN    (SA6 "ORECLEN")
            GEN    (SB2 A2) 
            GEN    (SB3 X5) 
            NEWLBL NEXT 
            GEN    (EQ B2,B3,"NEXT")     *IF SAME ADDR TO MOVE
  
            GEN    (SB2 10)              *NO CHAR/WORD
            GEN    (SB3 X3)              *VALUE OF OUTRL1 
  
  
            GENLBL GRILOOP2 
            GEN    (BX6 X2) 
            GEN    (SA6 X5)              *COPY TO 1ST WORD OF WSAS$OREC 
            GEN    (SA2 A2+B1)           *NEXT WORD 
            GEN    (SX5 X5+B1)
            GEN    (SB3 B3-B2)           *DECREMENT CHAR COUNT
            GEN    (LT B0,B3,"GRILOOP2") *IF MORE WORDS TO MOVE 
  
* 
* RESET GETENTRY TO 0 
* 
  
            GENLBL NEXT 
            GEN    (MX6 0)
            GEN    (SA6 "GETENTRY") 
  
            NEWLBL LABEL3 
            GEN    (EQ "LABEL3")
  
          GENLBL SRECLEN
          GENMAC (DATA 0)    *CHAR LENGTH OF SAVED REC
  
            GENLBL LABEL2 
* 
  
*         INCREMENT THE ELEMENT OF S$ARRY WHICH HOLDS THE COUNT OF
*         THE NUMBER OF RECORDS INSERTED BY OWN1
            GEN  (SA5 S$ARRY+2)        *GET COUNT OF REC.S INSERTED 
            GEN  (SX7 B1) 
            GEN  (IX7 X5+X7)           *INCREMENT COUNT FOR OWN1
            GEN  (SA7 A5)              *UPDATE STAT. ARRAY ELEMENT
  
* SAVE RECORD AT ADDR OUTARR1 ( LENGTH IN OUTRL1 ) AT SAVEREC 
* 
            GEN    (BX6 X3) 
            GEN    (SA6 "SRECLEN")
            GEN    (SB2 10)              *NO CHAR/WORD
            GEN    (SB3 X3)              *VALUE OF OUTRL1 
            GEN    (SA5 "SAVEREC")
  
            GENLBL GRILOOP3 
            GEN    (BX6 X2) 
            GEN    (SA6 A5)              *COPY EACH WORD FROM OWN1
            GEN    (SA2 A2+B1)           *  TO SAVEREC AREA 
            GEN    (SA5 A5+B1)
            GEN    (SB3 B3-B2)           *DECREMENT CHAR COUNT
            GEN    (LT B0,B3,"GRILOOP3") *IF MORE WORDS TO MOVE 
  
            GEN    (SX6 1)               *SET GETENTRY TO ENTRY1
            GEN    (SA6 "GETENTRY") 
  
  
            GENLBL LABEL3 
  
            ENDIF.
  
          GEN    (SA1 "WSA")
          GEN    (SB2 X1) 
          NEWLBL GOTUREC
          GEN    (EQ "GOTUREC") 
  
*     DECLARE "ORECLEN" 
  
          GENLBL ORECLEN
          GEN    (PS) 
          SA1    FASTIO 
          IFTHEN X1<0 
            SX1    0
            ENDIF.
          GEN    (PS 0),X1
  
*     GENERATE-   "GETENTRY" WITH A VALUE FOR NORMAL PROCESSING.
  
          GENLBL GETENTRY 
          GENMAC (DATA 0) 
* 
* GENERATE AN ARRAY TO SAVE THE FITS AT COMPILE TIME TO BE USED 
*    AT EXECUTION TIME. THE ARRAY TERMINATE WITH A ZERO WORD
* GENERATE A POINTER IFIT POINTING TO THE ADDRESS OF CURRENT FIT
*          THIS POINTER IS ORIGINALLY SET TO "IFIT" + 1 
* 
  
          GENLBL INDXFIT
          GENMAC (DATA 0)              *ADDR OF INDEX TO IFITARRAY
  
          GENLBL IFIT                  *FIT ADDRESS 
          GEN    (PS) 
          GEN    (PS 1+"IFIT")
          SA5    A0+5        ADDR OF FITARRAY PARAM.
          SA5    X5          X5 = ADDR OF FIRST FIT 
  
 GENFIT   GEN    (PS) 
          SA1    A5          X1 = <FIT ADDRESS> 
          GEN    (PS 0),X1             *FIT ADDRESS 
  
          SA5    A5+B1       ADDRESS OF NEXT FIT
          SB5    B5-B1       DECREMENT NO OF INPUT FILES
          GT     B5,GENFIT   IF MORE FIT TO COPY
  
          GENMAC (DATA 0)              *TERMINATOR FOR FIT ARRAY
  
          NEWLBL FNL1 
          GENLBL FNL1 
          GENMAC (DATA 5LINPUT) 
  
  
  
*     GENERATE-   "EOF":     DISPOSE OF INPUT FILE. 
*                        (IF ANOTHER INPUT FILE)
*                            OPEN NEXT INPUT FILE.
*                            GO TO "GETREC".
*                        (END OF ANOTHER-INPUT-FILE)
  
          GENLBL EOF
 #HAVEB6  SET    1           STOP GENMAC FROM GRIPING ABOUT SB6 
          SA1    FASTIO 
          IFTHEN X1=0        IF RECORD MANAGER IS USED, 
            GENMAC (DATA -0)
            ENDIF.
  
          GENLBL GRILBL1
  
          GEN    (SA1 "IFIT")          *ADDR OF INPUT FIT 
          GEN    (SA2 "INDXFIT")
          GEN    (SA2 X2) 
          GEN    (IX1 X1+X2)
          GEN    (SA1 X1) 
          GEN    (SA0 X1)              *A0 = ADDRESS OF FIT 
  
  
          GENMAC (FETCH A0,LFN,X0)
          GEN    (SA5 "FNL1")          *INPUT     * 
          GEN    (IX0 X0-X5)
          NEWLBL FNL2 
          GEN    (NZ X0,"FNL2")        *IF NOT *INPUT     * 
  
          SA1    FASTIO 
          IFTHEN X1=0        IF RECORD MANAGER IS USED, 
            NEWLBL NEXT 
            GEN    (SB6 "NEXT") 
 #HAVEB6    SET    1
              GENMAC (CLOSEM A0,DET)      *CLOSE W/ DETACH
            GENLBL NEXT 
            ENDIF.
  
          NEWLBL FNL3 
          GEN    (EQ "FNL3")           *SKIP FOLLOWING PART 
  
  
          GENLBL FNL2                  *IF FILE IS NOT *INPUT     * 
          SA1    FASTIO 
          IFTHEN X1"0        IF FAST INPUT IS USED, 
            IFTHEN X1<0            IF RT=W
              GEN    (SA1 A0+B1)   RESET BUFFER POINTERS
              GEN    (SX6 X1) 
              GEN    (SA6 A1+B1)            *IN 
              GEN    (SA6 A6+B1)            *OUT
              ENDIF.
          ELSE-              IF RECORD MANAGER IS USED, 
  
*             ENSURE THAT FILE POSITION = END OF SECTION
*             DOES NOT TERMINATE READING
  
            GENMAC (FETCH A0,FP,X0)      *FETCH FILE POSITION 
            GEN    (SX1 10B)             *10B = END OF SECTION
            GEN    (IX1 X1-X0)           *IF EOS, 
            GEN    (ZR X1,"GETREC")      *GO READ AGAIN 
  
*         ENSURE THAT INPUT FILE IS NOT REWOUND IF USER 
*         SET CF=N
*         IGNORE CF IF SORT 4 CALLING SEQUENCE
  
            SA1    =XS$CALLR   WHO CALLED SORT MERGE
            SB7    3
            SB6    X1 
            IFTHEN   B6"B7      IF NOT SORT 4 CALL
              GENMAC (FETCH A0,CF,X1)      *0,1 MEANS REWIND
              GEN    (AX1 1)               *0,1 --> 0; ELSE NONZERO 
              NEWLBL NEXT 
              GEN    (NZ X1,"NEXT") 
              GEN    (SB6 "NEXT") 
 #HAVEB6      SET    1
              GENMAC (REWINDM A0) 
              GENLBL NEXT 
            ELSE-                   IF SORT 4 CALL, REWIND
              NEWLBL NEXT 
              GEN    (SB6 "NEXT") 
 #HAVEB6      SET    1
              GENMAC (REWINDM A0) 
              GENLBL NEXT 
              ENDIF.
  
            NEWLBL NEXT 
            GENMAC (FETCH A0,CF,X1) 
            GEN    (SX0 3)           #U#
            GEN    (IX1 X0-X1)
            GEN    (NZ X1,"NEXT")    JUMP IF NOT -UNLOAD- 
            GEN    (SB6 "FNL3")      RETURN ADDRESS FOR CRM 
 #HAVEB6    SET    1                 TELL CRM WE HAVE IT
            GENMAC (CLOSEM A0,U)     CLOSE AND UNLOAD 
            GENLBL NEXT 
  
            NEWLBL NEXT 
            GENMAC (FETCH A0,CF,X1) 
            GEN    (SX0 4)           #RET#
            GEN    (IX0 X0-X1)
            GEN    (NZ X0,"NEXT") 
            GEN    (SB6 "FNL3") 
 #HAVEB6    SET    1
            GENMAC (CLOSEM A0,RET)
            GENLBL NEXT 
  
            NEWLBL NEXT 
            GEN    (SB6 "NEXT") 
 #HAVEB6    SET    1
            GENMAC (CLOSEM A0,DET)
            GENLBL NEXT 
            ENDIF.
  
          GENLBL FNL3 
          SA1    FASTIO 
          IFTHEN X1"0        IF FAST INPUT IS USED, 
            GENMAC (REWIND A0,RECALL) 
            GENMAC (FETCH A0,FWB,X1)   *X1 = ADDRESS OF BUFFER
            GEN    (CALL CMM.FRF)      *FREE THE BLOCK
                   *SAVES AX0,X5,B2-3 
            NEWLBL  NEXT         FORCE UPPER FOR CALL TO
            GENLBL  NEXT         CMM.FRF
            ENDIF.
  
  
          SA1    A0+4        ADDRESS OF <NO OF INPUT FILES> 
          SA1    X1          VALUE OF <NO OF INPUT FILES> 
          SB5    X1          B5 = <NO OF INPUT FILES> 
  
          IFTHEN B5"B1       IF MORE THAN 1 INPUT FILE
  
            GEN    (SA1 "INDXFIT")
            GEN    (SA1 X1) 
            GEN    (SX1 X1+B1)
            GEN    (SA2 "IFIT") 
            GEN    (IX2 X1+X2)
            GEN    (SA2 X2) 
            NEWLBL GRILBL3
            GEN    (ZR X2,"GRILBL3")     *IF NO MORE INPUT FIT
            GEN    (BX6 X1)              *INCREMENT INDEX TO FITARRAY 
            GEN    (SA6 A1) 
            GEN    (SA0 X2)            *A0 = ADDRESS OF CURRENT FIT 
  
* 
* OPEN NEXT INPUT FILE IF NOT ALREADY OPENED
* 
            GEN    (SX6 "EOF")
            GENMAC (STORE A0,DX=X6) 
            GEN    (SA5 "WSA")
            GEN    (SX5 X5+0),B4         *SX5 (WSA)+OREC
            GENMAC (STORE A0,WSA=X5)
  
            GENMAC (FETCH A0,OC,X5)    *CHECK WHETHER FILE IS OPEN
            GEN    (SX5 X5-1)            * 1=#OPE#,CODE FOR OPENED
            NEWLBL GRIMOVE1 
            GEN    (ZR X5,"GRIMOVE1")    *IF FILE OPENED
  
          SA1    FASTIO 
          IFTHEN X1"0        IF FAST INPUT IS USED, 
            GENMAC (FETCH A0,BFS,X2)   *X2 = SIZE FOR BUFFER
            GEN    (SB2 X2)            *PRESERVE IN B2
            GEN    (MX3 0)             *X3 = GROUP-ID, SIZE-CODE
            GEN    (CALL CMM.ALF)      *SET X1 = BLOCK FWA
                   *SAVES AX0,X5,B2-3 
            GENMAC (STORE A0,FWB=X1)   *FIRST 
                   *USES AX5-6,X7 
            GEN    (SX6 X1) 
            GEN    (SA6 A0+2)          *IN
            GEN    (SA6 A6+B1)         *OUT 
            GEN    (SX1 X1+B2)         *FWB + BFS 
            GEN    (SA5 A6+B1)
            GEN    (MX6 -18)
            GEN    (BX6 X6*X5)
            GEN    (BX6 X6+X1)
            GEN    (SA6 A5)            *LIMIT 
            GEN    (MX6 1)             *CLEAR EP BIT FOR FASTIO 
            GEN    (LX6 45) 
            GEN    (SA5 A0+1)          *EP BIT IS IN FET + 1
            GEN    (BX6 -X6*X5)        *CLEAR EP BIT IN FET 
            GEN    (SA6 A5)            *STORE BACK IN FET + 1 
            ENDIF.
            GEN    (SA5 "FNL1")        *INPUT     * 
            GEN    (IX0 X0-X5)
            NEWLBL GRIMOVE2 
            GEN    (ZR X0,"GRIMOVE2")    *IF FILE IS *INPUT*
            SA1    FASTIO 
            IFTHEN X1"0      IF FAST INPUT IS USED, 
              GENMAC (REWIND A0,RECALL) 
              SA1    FASTIO 
              PL     X1,GNGR1.5    IF RT=F, SKIP
              GEN    (SA1 A0+B1)
              GEN    (MX6 0)
              GEN    (SA6 X1) 
              GENMAC (READ A0,RECALL) 
              GEN    (SA1 A0+3)              *OUT 
              GEN    (SX6 X1+B1)             *SKIP BLOCK CONTROL WORD 
              GEN    (SA6 A1) 
 GNGR1.5      BSS    0
            ELSE-            IF RECORD MANAGER IS USED, 
              NEWLBL NEXT 
              GEN    (SB6 "NEXT")      *RETURN ADDRESS AFTER OPENM
 #HAVEB6      SET    1
              GENMAC  (OPENM A0,INPUT)  * SET PD=INPUT,OPEN WITH REWIND 
              GENLBL NEXT 
              ENDIF.
            GEN    (EQ "GETREC")
  
  
            GENLBL GRIMOVE2 
            SA1    FASTIO 
            IFTHEN X1"0        IF FAST INPUT IS USED
              PL     X1,GNGR1.6     IF RT=F, SKIP 
              GEN    (SA1 A0+B1)
              GEN    (MX6 0)
              GEN    (SA6 X1) 
              GENMAC (READ A0,RECALL) 
              GEN    (SA1 A0+3)             *OUT
              GEN    (SX6 X1+B1)            *SKIP BLOCK CONTROL WORD
              GEN    (SA6 A1) 
 GNGR1.6      BSS    0
            ELSE-              IF RECORD MANAGER IS USED
              NEWLBL NEXT 
              GEN    (SB6 "NEXT")      *RETURN ADDRESS AFTER OPENM
 #HAVEB6      SET    1
              GENMAC (OPENM A0,INPUT,N) *OPEN NEXT FILE WITHOUT REWIND
              GENLBL NEXT 
              ENDIF.
            GEN    (EQ "GETREC")
  
            GENLBL GRIMOVE1 
          GENMAC (FETCH A0,LFN,X0)
            GEN    (SA5 "FNL1")        *INPUT     * 
            GEN    (IX0 X0-X5)
  
            GEN    (ZR X0,"GETREC")      *IF FILE = *INPUT* 
  
            NEWLBL NEXT 
            GEN    (SB6 "NEXT") 
 #HAVEB6  SET    1
          GENMAC (REWINDM A0) 
            GENLBL NEXT 
            GEN    (EQ "GETREC")
  
            GENLBL GRILBL3
  
            ENDIF.
  
  
*     GENERATE-          (IF OWN2 PROCEDURE)
*                            SET "GETENTRY" = "ENTRY2". 
*                 "ENTRY2":  CALL OWN2 PROCEDURE TO DETERMINE <ACTION>. 
*                            IF <ACTION> = *INSERT*,
*                                COPY USER RECORD TO WSAS$OREC
*                                GO TO "GOTUREC". 
*                        (END OF -OWN2-PROCEDURE) 
  
  
          IFTHEN B3"0        IF OWN2 PROCEDURE SPECIFIED
  
            GEN    (MX6 60)               *X6 = - 0 
            GEN    (SA6 "GETENTRY") 
  
            GENLBL ENTRY2 
* 
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
              GEN    (SA1 "APLIST")      *APLIST = NRA,RECADDR,RECLEN 
              GEN    (MX6 0)
              GEN    (SA6 X1)            *ZERO OUT NRA
              GEN    (SA6 "ORECLEN")   *ZERO OUT RECLEN 
            ELSE- 
              GEN    (SA1 A6)            *APLIST = RECADDR,RECLEN 
              ENDIF.
  
            NEWLBL NEXT 
            GEN    (SX6 "NEXT")        *RETURN ADDR FROM SMRTN
            GEN    (SA6 S$RTNAD)
  
            GEN    (RJ 0),B3           *RJ OWNCODE2 
            GEN    (SB0 0)
  
          SA4    A0+7        ADDRESS OF SPEC$OWNT 
          SA4    X4          VALUE OF SPEC$OWNT 
* 
* USER GOT HERE WITH NORMAL RETURN, ONLY OK WITH FTN5 INTERFACE 
* 
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
              GEN    (SA1 "APLIST")        *USE SAME APLIST FOR FTN5
              NEWLBL LABEL5 
              GEN    (EQ "LABEL5")
            ELSE- 
  
              GEN    (SA1 "ERROR1") 
              GEN    (RJ =XS$ERROR)      *CALL ERROR ROUTINE
              GEN    (SA1 "ERROR0")      *ZERO TO PRINT ERROR 
              GEN    (RJ =XS$ERROR) 
              GEN    (RJ =XS$ABT)           *CALL SORT5 ABORT ROUTINE 
  
            ENDIF.
  
  
  
            GENLBL NEXT                *RETURN HERE FROM SMRTN
  
            IFTHEN X4"0        IF SPEC$OWNT (SM5 INTERFACE) 
            GEN    (SA1 "ERROR2") 
              GEN    (RJ =XS$ERROR)      *CALL ERROR ROUTINE
              GEN    (SA1 "ERROR0")      *ZERO TO PRINT ERROR 
              GEN    (RJ =XS$ERROR) 
              GEN    (RJ =XS$ABT)        *SORT5 ABORT ROUTINE 
  
  
              GENLBL LABEL5 
              ENDIF.
  
            GEN    (SB1 1)             *CONSTANT 1
                                         * A1 SET TO APLIST ABOVE FOR FTN5
                                         * OR SET IN FTN4 PROGRAM 
            GEN    (SA2 X1)            *X2 = NRA
            NEWLBL NEXT 
            GEN    (PL X2,"NEXT")        *IF NRA IS POSITIVE
  
            GEN    (SA1 "ERROR3")         * E$155 
            GEN    (RJ =XS$ERROR) 
            GEN    (SA1 "ERROR0")      * ZERO TO PRINT ERROR
            GEN    (RJ =XS$ERROR) 
            GEN    (RJ =XS$ABT)          *SORT5 ABORT ROUTINE 
  
            GENLBL NEXT 
            NEWLBL NEXT 
            GEN    (SX0 X2-4) 
            GEN    (MI X0,"NEXT")        *IF NRA LE 3 
  
            GEN    (SA1 "ERROR3")         * E$155 
            GEN    (RJ =XS$ERROR) 
            GEN    (SA1 "ERROR0")      * ZERO TO PRINT ERROR
            GEN    (RJ =XS$ERROR) 
            GEN    (RJ =XS$ABT)          *SORT5 ABORT ROUTINE 
  
            GENLBL NEXT 
            GEN    (SX0 X2) 
            NEWLBL GRILBL2
            GEN    (ZR X2,"GRILBL2")   *IF EOF FROM OWNCODE2
  
*         INCREMENT THE ELEMENT OF S$ARRY WHICH HOLDS THE COUNT OF
*         THE NUMBER OF RECORDS INSERTED BY OWN2
            GEN  (SA2 S$ARRY+3)        *GET COUNT OF RECS INSERTED
            GEN  (SX7 B1) 
            GEN  (IX7 X2+X7)           *INCREMENT COUNT FOR OWN2
            GEN  (SA7 A2)              *UPDATE STAT. ARRAY
  
  
            GEN    (SA2 A1+B1)         *ADDRESS OF OUTARR1
            GEN    (SA2 X2)            *VALUE OF OUTARR1
            GEN    (SA3 A1+2)          *ADDRESS OF OUTRL1 
            GEN    (SA3 X3)            *VALUE OF OUTRL1 
* 
* MOVE RECORD AT ADDR OUTARR1 WITH LENGTH IN OUTRL1 TO OREC 
* 
            GEN    (SA5 "WSA")
            GEN    (SX5 X5+0),B4       *SX5 WSA+OREC ADDR 
  
            GEN    (BX6 X3) 
            GEN    (SA6 "ORECLEN")
            GEN    (SB2 A2) 
            GEN    (SB3 X5) 
            NEWLBL NEXT 
            GEN    (EQ B2,B3,"NEXT")     *IF SAME ADDR TO MOVE
  
            GEN    (SB2 10)              *NO CHAR/WORD
            GEN    (SB3 X3)              *VALUE OF OUTRL1 
  
  
            GENLBL GRIMOVE4 
            GEN    (BX6 X2) 
            GEN    (SA6 X5)            *COPY TO 1ST WORD OF WSAS$OREC 
            GEN    (SA2 A2+B1)           *NEXT WORD 
            GEN    (SX5 X5+B1)
            GEN    (SB3 B3-B2)         *DECREMENT CHAR COUNT
            GEN    (LT B0,B3,"GRIMOVE4")  *IF MORE WORDS TO MOVE
  
* 
            GENLBL NEXT 
            GEN    (SA1 "WSA")
            GEN    (SB2 X1) 
  
            GEN    (EQ "GOTUREC") 
  
            GENLBL GRILBL2
            ENDIF.
  
*     GENERATE-              SET "GETENTRY" TO "ENTRY3" 
*                 "ENTRY3":  SET REGISTER = END-OF-DATA.
*                            GO TO "GOTIREC". 
  
          GEN    (MX6 1)               *X6 = NON-ZERO 
          GEN    (SA6 "GETENTRY") 
  
          GENLBL ENTRY3 
          GEN    (BX6 X0-X0)           *X6 = 0
          NEWLBL GOTIREC
          GEN    (EQ "GOTIREC") 
  
          IFTHEN B2"0        IF OWN1 PROC EXISTS
  
            SA1    A0+3        ADDR OF NOWORDS IN EXT-REC 
            SA1    X1          VALUE OF NOWORDS IN EXT-REC
            SB5    X1          B5 = NOWORDS IN EXT-REC
  
*     GENERATE-  "SAVEREC": SPACE TO SAVE A RECORD FROM OWN1
*                           IN CASE OF INSERT (SPEC$MRL*-1)/10 +1 WORDS LONG
* 
            GENLBL SAVEREC
  
 GENWORD    GENMAC (DATA 0) 
            SB5    B5-B1        DECREMENT NOWORDS IN-EXT-REC
            GT B5,GENWORD       IF NOT ENOUGH SPACE 
  
            ENDIF.
  
* 
*     GENERATE-   "GOTUREC":    
  
          GENLBL GOTUREC
  
*         INCREMENT THE ELEMENT OF S$ARRY WHICH HOLDS THE COUNT OF
*         THE TOTAL RECORD LENGTH 
            GEN  (SA1 "ORECLEN")       *GET CURRENT REC. LENGTH 
            GEN  (SA3 S$ARRY+13)       *GET TOTAL OF REC. LEN.
            GEN  (IX7 X3+X1)           *ADD CURRENT RECLEN TO TOTAL 
            GEN  (SA7 A3)              *UPDATE COUNT
  
  
          EXIT
          TITLE  GETFAST -  GENERATE-   GET EXTERNAL RECORD VIA FAST I/O
**        GETFAST -  GENERATE-   GET EXTERNAL RECORD VIA FAST I/O 
* 
*     CALLING SEQUENCE- 
*         CALL   GETFAST
* 
*     GIVEN-
*         FASTIO NON-ZERO,
*           > 0 IF RT=F, FL=FASTIO FOR ALL INPUT RECORDS
*           < 0 IF RT=W, MRL=-FASTIO FOR ALL INPUT RECORDS
*         B4 = WORD OFFSET WITHIN WSA$ FOR EXTERNAL RECORD (OREC) 
* 
*     DOES- 
*         GENERATES CODE. 
* 
*     GENERATED CODE DOES-
*         TRIES TO READ A RECORD FROM THE FIT WHOSE ADDRESS 
*         IS POINTED TO BY "IFIT".
*         IF SUCCESSFUL,
*             SETS WSA$+OREC TO THIS RECORD 
*         ELSE, 
*             JUMPS TO "EOF". 
  
  
 GETFAST  SUBR
          GEN    (SA1 "IFIT")          *ADDRESS OF (ONLY) FIT ADDRESS 
          GEN    (SA2 "INDXFIT")
          GEN    (SA2 X2) 
          GEN    (IX1 X1+X2)
          GEN    (SA1 X1) 
          GEN    (SA0 X1)              *A0 = FIT ADDRESS
          SA1    FASTIO      > 0 FOR RT=F, < 0 FOR RT=W 
          IFTHEN X1\0        IF BT=C, RT=F, FL=-<FASTIO>
            SX2    1S20/10+1   1/10 * 2**20 
            IX7    X1*X2       FL/10 * 2**20
            AX7    20          X7 = FL/10 
            SX2    10 
            IX2    X7*X2       (FL/10)*10 
            IX6    X1-X2       0 IFF FL A MULTIPLE OF 10
            SA6    FLMULT10 
            GENLBL FAST1
           *USES   AX1-3,AX6,B6-7 
            GEN    (SA4 A0+3)          *OUT 
           *USES   X0,AX1-3,AX6,B6-7
            GEN    (SA3 A4-B1)         *IN
            GEN    (IX0 X4-X3)         *IN - OUT = 0 FOR EMPTY BUFFER 
            NEWLBL FAST6
            GEN    (ZR X0,"FAST6")     *IF EMPTY BUFFER, SKIP 
            SA1    FLMULT10    0 IFF FL A MULTIPLE OF 10
            IFTHEN X1"0       IF FL NOT A MUTIPLE OF 10 
              CALL   GENCHECK  IF EOF, JUMP TO -EOF-
              ENDIF.
            GEN    (SA3 A4+B1)         *LIMIT 
            GEN    (SX3 X3-1)          *LIMIT - 1 
            GEN    (IX0 X4-X3)         *OUT VS. LIMIT - 1 
            NEWLBL FAST2
           *USES   AX1,AX6,B6-7 
            GEN    (NZ X0,"FAST2")
            SA1    FLMULT10 
            IFTHEN X1"0        IF FL NOT A MULTIPLE OF 10 
              CALL GENFTBL   *SETS 'FASTM', 'FASTS' AND S$FSTPS 
             *SAVES  A0,A5,AX7,B2-B5
              GEN    (SA3 S$FSTPS)
              GEN    (NZ X3,"FAST2")
              ENDIF.
            GENLBL FAST6
            GEN    (SA1 A0)            *42/LFN, 18/CODE+STATUS
            GEN    (LX1 -5)            *EXAMINE EOR BIT 
          NEWLBL NEXT 
          GEN    (PL X1,"NEXT")   *IF NOT E-O-R, JUMP 
          GEN    (LX1 1)          *NOW GET E-O-F BIT
          GEN    (NG X1,"EOF")    *IF END-OF-FILE, JUMP 
          GENLBL NEXT 
            GEN    (SA2 A0+B1)         *FIRST 
            GEN    (SX6 X2)            *CLEAR UPPER 42 FOR NOS
            GEN    (SA6 A2+B1)         *SET IN = FIRST
            GEN    (SA6 A6+B1)         *SET OUT = FIRST 
            GEN    (MX6 0)
            GEN    (SA6 S$FSTPS)         *RESET SHIFTS AND MASKS
            GENMAC (READ A0,RECALL)    *FILL BUFFER 
           *USES   AX1-3,AX6,B6-7 
            GEN    (EQ "FAST1") 
  
            GENLBL FAST2
            SA1    FLMULT10 
            IFTHEN X1=0        IF FL A MULTIPLE OF 10 
              GEN    (SA5 X4)          *WORD POINTED TO BY OUT
              GEN    (BX6 X5) 
              GEN    (SA1 "WSA")       *ADDRESS OF WSA$ 
              GEN    (SA6 X1+0),B4     *STORE IN WSA$+OREC
 GNGR1.1      SX7    X7-1        DECREMENT NUMBER OF WORDS TO MOVE
              ZR     X7,GNGR1.2  IF NO MORE WORDS, LOOP 
              GEN    (SA5 A5+B1)       *GET ANOTHER WORD FROM BUFFER
              GEN    (BX6 X5) 
              GEN    (SA6 A6+B1)       *STORE IN OREC 
              EQ     GNGR1.1
 GNGR1.2      GEN    (SX6 A5+B1)       *NEW VALUE FOR OUT 
              GEN    (SA6 A0+3)        STORE IN FET 
            ELSE-            IF FL NOT A MULTIPLE OF 10 
              GEN    (SA2 S$FSTPS)
              GEN    (SA1 X2+"FASTS")  *2/1,10/SHIFT,30/OUT,18/NEXT 
              GEN    (SX6 X1)          *INDEX TO NEXT ENTRY 
              GEN    (SA6 A2)          *STORE FOR NEXT TIME 
              GEN    (SA2 X2+"FASTM")  *MASK
              GEN    (UX1 B7,X1)       *SHIFT 
              GEN    (AX1 18)          *OFFSET FOR OUT POINTER
              GEN    (SB6 X1)          *B6 = OFFSET 
              GEN    (SA5 X4)          *WORD POINTED TO BY OUT
              GEN    (BX6 -X2*X5)      *GET RIGHT PART OF WORD
              GEN    (SA5 A5+B1)       *GET NEXT WORD FROM BUFFER 
              GEN    (BX1 X2*X5)       *GET LEFT PART OF WORD 
              GEN    (BX6 X1+X6)       *COMBINE PARTS 
              GEN    (LX6 X6,B7)       *PROPERLY ALIGN WORD 
              GEN    (SA1 "WSA")       *WSA$
              GEN    (SA6 X1+0),B4     *STORE IN WSA$+OREC
 GNGR1.3      SX7    X7-1        DECREMENT NUMBER OF WORDS TO MOVE
              NG     X7,GNGR1.4  IF DONE, SKIP OUT
              GEN    (BX6 -X2*X5)      *GET RIGHT PART OF WORD
              GEN    (SA5 A5+B1)       *GET NEXT WORD FROM BUFFER 
              GEN    (BX1 X2*X5)       *GET LEFT PART OF WORD 
              GEN    (BX6 X1+X6)       *COMBINE PARTS 
              GEN    (LX6 X6,B7)       *PROPERLY ALIGN WORD 
              GEN    (SA6 A6+B1)       *APPEND TO WORDS IN WSA$+OREC
              EQ     GNGR1.3     GO HANDLE NEXT WORD
  
 GNGR1.4      GEN    (SX6 A5+B6)       *NEW VALUE FOR OUT 
              GEN    (SA6 A0+3)        *STORE *OUT* IN FET
              ENDIF.
          ELSE-              IF BT=I, RT=W, MRL=-FASTIO 
            GENLBL FAST1               *HERE TO COPY ENTIRE RECORD
            GEN    (MX3 0)             *CLEAR WORDS, UNUSED BITS
            GENLBL FAST2               *HERE TO GET CONTROL WORD OF A PIECE 
            GEN    (SA5 A0+3)          *OUT 
            GEN    (SA4 X5)            *PIECE CONTROL WORD
            GEN    (SB7 X4)            *0 IFF LAST PIECE IN BLOCK 
            NEWLBL FAST3
            GEN    (NZ B7,"FAST3")     *IF NOT END-OF-BLOCK 
            GEN    (SA4 A0)            *42/LFN, 18/CODE+STATUS
            GEN    (LX4 -5)            *EXAMINE END-OF-RECORD BIT 
          NEWLBL NEXT 
          GEN    (PL X4,"NEXT")   *IF NOT E-O-R, JUMP 
          GEN    (LX4 1)          *NOW GET E-O-F BIT
          GEN    (NG X4,"EOF")    *IF END-OF-FILE, JUMP 
          GENLBL NEXT 
            GEN    (SA4 A0+B1)         *FIRST 
            GEN    (SX6 X4) 
            GEN    (SA6 A4+B1)         *IN := FIRST 
            GEN    (SA6 A6+B1)         *OUT := FIRST
            GENMAC (READ A0,RECALL)    *TRY TO FILL BUFFER
                                       **USES AX1,X2,AX6,X7 
            GEN    (SA5 A0+3)          *OUT := OUT + 1
            GEN    (SX6 X5+B1)         *(SKIP BLOCK CONTROL WORD) 
            GEN    (SA6 A5) 
            GEN    (EQ "FAST2")        *GO SEE IF SUCCESSFUL
  
            GENLBL FAST3               *HERE TO LOOK AT CONTROL WORD
*         X3 = 42/<TOTAL UNUSED BITS>, 18/<TOTAL WORDS> 
*         X5 = VALUE OF *OUT*, POINTING TO PIECE CONTROL WORD 
*         A5 = ADDRESS OF *OUT* 
*           X4 = 1/(ODD) PARITY BIT,
*                1/F = FLAG FOR END-OF-SECTION/PARTITION
*                1/D = 1 TO DELETE NEXT RECORD, 
*                3/RESERVED FOR USERS,
*               10/RESERVED FOR CDC,
*                2/WCR = 0 => COMPLETE RECORD 
*                      = 1 => FIRST PIECE OF W-CONTINUATION RECORD
*                      = 2 => MIDDLE PIECE OF W-CONTINUATION RECORD 
*                      = 3 => LAST PIECE OF W-CONTINUATION RECORD 
*                6/NUMBER OF RIGHTMOST UNUSED BITS IN THE LAST WORD 
*               18/WORDS OF THIS RECORD (PIECE), NOT INCL. CTL. WORD
            GEN    (SX6 X4+B1)         *LENGTH OF PIECE, INCL CTL WD
            GEN    (IX6 X5+X6)         *OUT := OUT + LENGTH 
            GEN    (SA6 A5) 
            GEN    (SB5 X5+B1)            *SAVE ADDRESS OF RECORD 
            GEN    (IX2 X4+X4)         *PRESERVE CONTROL WORD 
            GEN    (NG X2,"EOF")       *IF END-OF-SECTION/PARTITION 
            GEN    (MX0 -24)
            GEN    (BX0 -X0*X4)        *WORDS, UNUSED BITS
            GEN    (IX3 X3+X0)         *UPDATE WORDS, UNUSED BITS 
            GEN    (SB6 X3)            *NUMBER OF WORDS TO COPY 
            GEN    (SB7 B0)            *INDEX TO OREC 
            GEN    (SA1 "WSA")         *WSA$
            GEN    (SB3 X1+0),B4       *WSA$+OREC 
            GENLBL FAST4               *HERE TO COPY ANOTHER PART 
            NEWLBL FAST5
            GEN    (ZR B6,"FAST5")     *IF WORD COUNT IS ZERO, SKIP 
            GEN    (SA4 B5+B7)         *GET NEXT WORD FROM BUFFER 
            GEN    (BX6 X4) 
            GEN    (SA6 B3+B7)
            GEN    (SB7 B7+B1)
            GEN    (LT B7,B6,"FAST4") 
            GENLBL FAST5               *HERE WHEN PIECE COPIED
            GEN    (AX1 X2,B1)         *UNSHIFT CONTROL WORD
            GEN    (AX1 6+18)          *RIGHT JUSTIFY WCR 
            GEN    (MX0 -2) 
            GEN    (BX1 -X0*X1)        *KEEP ONLY RIGHT TWO BITS
            GEN    (SB7 X1-1) 
            GEN    (ZR B7,"FAST1")     *IF FIRST PIECE, GO FOR REST 
            GEN    (SB7 X1-2) 
            GEN    (ZR B7,"FAST2")     *IF MIDDLE PIECE, GO FOR REST
            GEN    (IX1 X2+X2)         *LOOK AT BIT 57 OF ORIG CTL WORD 
            GEN    (NG X1,"FAST1")     *IF DELETION, GO GET NEW RECORD
                                       *WE NOW HAVE A GOOD RECORD 
            GEN    (SX1 X3)            *WORDS USED
            GEN    (IX6 X1+X1)         *2*WORDS 
            GEN    (LX1 3)             *8*WORDS 
            GEN    (IX1 X1+X6)         *10*WORDS
            GEN    (AX5 18)            *UNUSED BITS 
            GEN    (SX0 1S19/6+1)      *1/6 * 2**19 
            GEN    (IX5 X5*X0)         *BITS/6 * 2**19
            GEN    (AX5 19)            *BITS/6
            GEN    (IX1 X1-X5)         *10*WORDS - BITS/6 = CHARACTERS
            GENMAC (STORE A0,RL=X1) 
            ENDIF.
          EXIT
  
  
 FLMULT10 BSS    1           0 IFF FL A MULTIPLE OF 10
          TITLE  GENCHECK -  GENERATE- IF EOF, JUMP TO -EOF-
**        GENCHECK - GENERATE- IF EOF, JUMP TO -EOF-
* 
*     CALLING SEQUENCE- 
*        CALL GENCHECK
* 
*     GIVEN-
*       FASTIO=FL FOR ALL INPUT RECORDS WHICH ARE RT=F
* 
*     DOES- 
*        GENERATES CODE.
* 
*     GENERATED CODE DOES-
*         *X0 IS IN-OUT, *X0"0. 
*         (IF FL IS MORE THAN 9)
*           IF ONLY PART WORD LEFT, JUMP TO -EOF- 
*         (IF FL IS NOT MORE THAN 9)
*           IF MORE THAN ONE WORD LEFT, JUMP TO -NEXT-
*           IF LESS THAN FL CHARACTERS IN WORD, JUMP TO -EOF- 
  
GENCHECK  SUBR
          GEN    (AX0 1)               *CHANGE -1 TO -0 
          SA1    FASTIO      FL 
          SX1    X1-10       FL-10
          IFTHEN X1\10       IF FL MORE THAN 9
            GEN    (ZR X0,"FAST6")     *IF ONLY PART WORD, CHECK EOF
          ELSE- 
            NEWLBL NEXT 
            GEN   (NZ X0,"NEXT")          *IF MORE THAN ONE WD.,NEXT
            GEN   (SA3 S$FSTPS)           *INDEX TO FASTIO TABLE
            NEWLBL FASTS       GENLBL DONE IN GENFTBL 
            GEN   (SA3 X3+"FASTS")        *2/1,10/SHIFT,30/OUT,18/NEXT
            GEN   (UX3 B7,X3)             *B7 = SHIFT TO L.J. PART
            SA1   FASTIO
            SB6   X1-10      FL 
            SB7   B6+B6      2*FL-20
            SB6   B7+B7      4*FL-40
            SB6   B6+B7      6*FL-60
            SB6   -B6        60 - 6*FL
            GEN   (SB6 0),B6
            GEN    (GT B7,B6,"FAST6")    *IF REC CANT FIT,CHECK EOF 
            GENLBL NEXT 
            ENDIF.
          EXIT
          TITLE  GETRM -  GENERATE- GET RECORD VIA RECORD MANAGER 
**        GETRM -  GENERATE- GET RECORD VIA RECORD MANAGER
* 
*     CALLING SEQUENCE- 
*         CALL   GETRM
  
  
 GETRM    SUBR
          GEN    (SA1 "IFIT")          *ADDRESS OF INPUT FIT
          GEN    (SA2 "INDXFIT")
          GEN    (SA2 X2) 
          GEN    (IX1 X1+X2)
          GEN    (SA1 X1)              *X1 = <FIT ADDRESS>
          GEN    (SA0 X1) 
          NEWLBL NEXT 
          GEN    (SB6 "NEXT")          *B6 = WORD AFTER *GET* 
 #HAVEB6  SET    1           TELL GENMAC TO NOT GENERATE (SB6 *+2)
          GENMAC (GET X1)              *DX = "EOF"
          GENLBL NEXT 
          GENMAC (FETCH A0,RL,X6) 
                 *USES  AX5,X7
          GENMAC (FETCH A0,RT,X1) 
          GEN    (SX2 X1-3)  #ZT# 
          NEWLBL NEXT 
          GEN    (NZ X2,"NEXT") 
          GENMAC (FETCH A0,FL,X6) 
          GENLBL NEXT 
          GEN    (SA6 "ORECLEN")
          EXIT
          TITLE  GENFTBL -  GENERATE FAST I/O TABLE 
**        GENFTBL -  GENERATE FAST I/O TABLE
* 
*     CALLING SEQUENCE- 
*         CALL GENFTBL
* 
*     GIVEN-
*         FASTIO = FL FOR ALL INPUT RECORDS, WHICH ARE RT=F.
* 
*     DOES- 
*         GENERATES CODE. 
* 
*     GENERATED CODE IS-
*         S$FSTPS = (FASTIO POSITIONING COUNTER) INDEX TO 
*         'FASTS' AND 'FASTM' FOR NEXT RECORD (INITIALLY ZERO)
*         "FASTM" = TABLE OF MASKS TO BE USED.
*         "FASTS" = TABLE OF SHIFTS AND SUCH TO BE USED:  
*                   2/1, 10/SHIFT, 30/<OUT OFFSET>, 18/<NEXT INDEX> 
* 
*     GENFTBL USES- 
*         B    * - - - - 6 7 *B1=1
*         X  0 1 2 3 4 5 6 -
*         A  - 1 2 3 4 - 6 -
  
  
 GENFTBL  SUBR
          NEWLBL NEXT 
          GEN    (EQ "NEXT")
          MX6    0
          SA6    S$FSTPS     INITIALIZE S$FSTPS TO ZERO 
          NEWLBL FASTM
          GENLBL FASTM
          SA4    FASTIO      FL FOR ALL INPUT RECORDS 
          SX0    6
          IX4    X0*X4       LENGTH := 6*FL 
          SX0    1S22/60+1   1/60 * 2**22 
          IX1    X0*X4       LENGTH/60 * 2**22
          AX1    22          LENGTH/60
          SX0    60 
          IX1    X0*X1       (LENGTH/60)*60 
          IX6    X4-X1       LENGTH MOD 60
          SA6    NEEDED      SAVE FOR COMPARE 
          MX5    0           OFFSET := 0
GENFTBL1  IFTHEN X5=0        IF MASK TO BE ALL 0
            GENMAC (DATA 0) 
          ELSE-              IF NEED TO COMPUTE MASK
            SB7    X5-1 
            MX0    1
            AX0    X0,B7
            GENWD  X0 
           *USES   AX1-3,AX6,B6-7 
            ENDIF.
          IX5    X5+X4       OFFSET := OFFSET + LENGTH
          SX0    1S22/60+1   1/60 * 2**22 
          IX1    X0*X5       OFFSET/60 * 2**22
          AX1    22          OFFSET/60
          SX0    60 
          IX1    X0*X1       (OFFSET/60)*60 
          IX5    X5-X1       OFFSET := OFFSET MOD 60
          NZ     X5,GENFTBL1 IF MORE TO DO, LOOP
  
*     GENERATE "FASTS" TABLE: 
*         2/1, 10/<SHIFT>, 30/<OUT OFFSET>, 18/<NEXT INDEX> 
  
                             X4 = 6*FL
                             ( NEWLBL WAS DONE IN GENCHECK )
          GENLBL FASTS
          SX6    A0          SAVE A0
          SA6    SAVEA0 
          MX5    0           OFFSET := 0
          SA0    B0          <NEXT INDEX> := 0
 GENFTBL2 SA0    A0+B1       <NEXT INDEX> := <NEXT INDEX> + 1 
          SX6    A0          42/0, 18/<NEXT INDEX>
          SB7    X5          <SHIFT>
          PX6    B7,X6       2/1, 10/<SHIFT>, 30/0, 18/<NEXT INDEX> 
          IX5    X5+X4       OFFSET := OFFSET + LENGTH
          SX0    1S21/60+1   1/60 * 2**21 
          IX1    X0*X5       OFFSET/60 * 2**21
          AX1    21          OFFSET/60
          SX0    60 
          IX1    X1*X0       (OFFSET/60)*60 
          IX5    X5-X1       OFFSET := OFFSET MOD 60
          SB6    60 
          SB7    B6-B7       BITS LEFT IN WORD
          SA1    NEEDED      BITS NEEDED TO FIT 
          SB6    X1 
          IFTHEN B7>B6       IF MORE THAN EHOUGH ROOM 
            MX1    17          18/-1, 42/0
            LX1    18+18       24/0, 18/-1, 18/0
            BX6    X6+X1       2/1, 10/<SHIFT>, 12/0, 18/OUTOFF, 18/<NEXT>
          ELSE-              IF NEXT CHAR IS IN NEXT WORD,
            IFTHEN  X5=0          IF RIGHT-JUSTIFIED
              MX1  -18
              BX6  X1*X6        CLEAR<NEXT INDEX> 
              ENDIF.
            ENDIF.
          GENWD  X6 
         *USES   AX1-2,AX6,B6,B7
          NZ     X5,GENFTBL2 IF MORE ENTRIES TO CREATE, LOOP
  
          SA1    SAVEA0 
          SA0    X1 
          GENLBL NEXT 
          EXIT
  
 NEEDED   BSS    1           BITS NEEDED TO FIT 
 SAVEA0   BSS    1           TO SAVE/RESTORE ORIGINAL VALUE OF A0 
          TITLE  DATA 
  
  
 FASTIO   BSS    1           +N FOR RT=F,FL=N,  -N FOR RT=F,MRL=N 
 S$ARRY   EXTERNAL
S$FSTPS   EXTERNAL
 S$RTNAD  EXTERNAL
  
  
          END 
