*DECK S$GNGIB 
          IDENT  S$GNGIB
          TITLE  S$GNGIB - GENERATE GET INTERNAL RECORD CODE
          COMMENT  GENERATE GET INTERNAL RECORD CODE. 
  
*CALL LBLPTR
  
          B1=1
  
  
**        S$GNGIB - GENERATE GET INTERNAL RECORD CODE 
* 
*     CALLING SEQUENCE- 
*         S$GNGIB(REC$LR, LONGKEY, REC$IRRL); 
* 
*     GIVEN-
*         REC$LR = NUMBER OF BITS TO HOLD RECORD NUMBER 
*         LONGKEY = NO OF WORDS OF REMAINDER OF KEY IN BUFFER.
*         REC$IRRL = INTERNAL RECORD LENGTH.
* 
*     DOES- 
*         GENERATE GET INTERNAL RECORD CODE 
* 
*     GENERATED CODE EXPECTS- 
*         A0=ADDR OF FET OF INTERNAL INPUT FILE.
*         B2=ADDR OF WSA/TRN
*         X2= INDEX TO TRN
*         X5= RECORD NUMBER (RN)
* 
*     GENERATED CODE DOES-
*                SAVE X2 IN <B4>
*         "GRILBL1":         B4=INDEX TO TRN
*                            OTHER REGS AS AT ENTRY 
*                SET <A3> TO IN POINTER OF INPUT FILE 
*                SET <A4> TO OUT POINTER OF INPUT FILE
*                IF BUFFER NOT EMPTY (I.E. X3"X4), GOTO "GRILBL2" 
*                    IF INPUT FILE IS END-OF-DATA 
*                      THEN SET X6=0, GOTO "GRILBL3" TO EXIT
*                      ELSE READ INTO BUFFER USING A0 
*                           COPY "LONGKEY" WORDS FROM FIRST POINTER TO
*                               LIMIT POINTER.
*                           GO BACK TO "GRILBL1" TO CHECK IN, OUT PTRS. 
* 
*         "GRILBL2":         B4=INDEX TO TRN
*                            A3=IN POINTER
*                            X3=WORD POINTED BY IN POINTER
*                            A4=OUT POINTER 
*                            X4=WORD POINTED BY OUT POINTER 
*                            OTHER REGS AS AT ENTRY 
*                MOVE WORD AT OUT (X4) INTO X6
*                SET OUT=OUT+1
*                IF OUT=LIMIT THEN SET OUT=FIRST (VIA A0,<A4>)
*                INSERT RN (IN X5) INTO X6
*                RESTORE X2 FROM B4 
* 
*     GENERATED CODE LEAVES REGS AS AT ENTRY
* 
  
  
          ENTRY  S$GNGIB
 S$GNGIB  SUBR               ENTRY/EXIT WORD
          SB1    1           CONSTANT 1 
  
* GET AND SAVE PARAMETERS 
* 
          SA2    X1          X2=VALUE OF REC$LR 
          SB5    X2          SAVE IN B5 
          SA3    A1+B1       ADDR OF LONGKEY
          SA3    X3          X3=VALUE OF LONGKEY
          SB4    X3 
          SA4    A1+2        ADDR OF REC$IRRL 
          SA4    X4          X4=REC$IRRL
* 
  
          GEN    (SB4 X2)              *PRESERVE INDEX TO TRN IN B4 
  
          GENLBL GRILBL1
  
          GEN    (SA3 A0+2)            *IN PTR
          GEN    (SA4 A3+B1)           *OUT PTR 
          GEN    (IX0 X3-X4)           * (IN-OUT) 
          NEWLBL NEXT 
          GEN    (PL X0,"NEXT")        *IF DATA IS FROM OUT TO IN 
                                       *DATA IS FROM OUT TO LIMIT 
                                       *  AND FROM FIRST TO IN
  
*     IF A FULL RECORD IS IN BUFFER, GO TO GRILBL2
*  IE IF (LIMIT - OUT) + (IN - FIRST) GE (IRRL + 1), GO TO GRILBL2
*  IE IF (IN - OUT) GE (IRRL + 1) + (FIRST - LIMIT), GO TO GRILBL2
  
          GEN    (SA1 A0+B1)           *FIRST 
          GEN    (SX1 X1)         *KEEP LOW 18 BITS 
          GEN    (SA2 A4+B1)           *LIMIT 
          GEN    (SX2 X2) 
          GEN    (IX1 X1-X2)           *FIRST - LIMIT 
          GEN    (SX1 X1+1+0),X4       *(IRRL + 1) + (FIRST - LIMIT)
          GEN    (IX2 X0-X1)           *(IN - OUT) - (ABOVE)
          NEWLBL GRILBL2
          GEN    (PL X2,"GRILBL2")     *IF FULL RECORD IN BUFFER, JUMP
          GEN    (MX0 2)               *ENSURE X0 WILL STAY NEGATIVE
          GENLBL NEXT 
  
          SX1    X4+B1       IRRL+1 
          BX1    -X1         -(IRRL+1)
          MX2    -17         MASK ALL EXCEPT LOW 17 BITS
          BX1    -X2*X1      SO THAT A NEGATIVE MODIFIER DOES NOT 
                             PROPAGATE TO OP CODE OF GEN
          GEN    (SX0 X0+400000B),X1   *X0=(IN-OUT)-(IRRL+1)
          GEN    (PL X0,"GRILBL2")     *IF I-O>N (ENOUGH DATA)
* 
* CASE CIO BUFFER IS EMPTY
* 
                                       *CHECK IF FILE IS EOD
          GEN    (SA1 A0)              *X1=WORD 0 OF FET OF FILE
          GEN    (MX0 -6)              *MASK FOR BIT 0-BIT 5
          GEN    (BX1 -X0*X1)          *CHECK BIT 0-BIT 5 OF FET
          GEN    (SX0 X1-21B)          *   FOR EOR, EOF 
          NEWLBL READBUF
          GEN    (MI X0,"READBUF")     *IF FILE NOT EOD 
          GEN    (SA1 A0+2)       *X1 := IN POINTER 
          GEN    (SA2 A1+B1)      *X2 := OUT POINTER
          GEN    (SX1 X1)         *KEEP LOW 18 BITS 
          GEN    (SX2 X2)         *KEEP LOW 18  BITS
          GEN    (IX1 X2-X1)      *IN MINUS OUT 
          GEN    (NZ X1,"GRILBL2")   *CASE OF SHORT RECORD
          GEN    (MX6 0)               * X6=0 
          NEWLBL GRILBL3
          GEN    (EQ "GRILBL3")        * EXIT WITH X6=EOD 
  
  
          GENLBL READBUF
                                       *READ INTO BUFFER
          GENMAC (READ A0,RECALL) 
  
* 
* COPY *LONGKEY* WORDS AT FIRST PTR TO LIMIT PTR FOR GNCMPC 
* 
          GEN    (SA1 A0+B1)           *FIRST PTR 
          GEN    (SA2 A4+B1)           *LIMIT PTR 
          GEN    (SA1 X1)              *X1=WORD POINTTED BY FIRST 
          GEN    (SA2 X2)              *X2=WORD POINTED TO BY LIMIT 
          GEN    (SB3 B0)              *INDEX 
          GEN    (SB5 0),B4            *COUNT *LONGKEY* WORDS 
  
          GENLBL GRILOOP1 
          GEN    (SA3 A1+B3)           *COPY WORD AT FIRST PTR
          GEN    (BX7 X3)              *   TO 
          GEN    (SA7 A2+B3)           * LIMIT PTR
          GEN    (SB3 B3+B1)           *INCREMENT COUNT 
          GEN    (LT B3,B5,"GRILOOP1") *IF MORE WORDS TO COPY 
  
          GEN    (EQ "GRILBL1")        *BACK TO TOP 
* 
* CASE BUFFER IS NOT EMPTY
* 
          GENLBL GRILBL2
          GEN    (SA1 X4)              *MOVE 1ST WORD AT
          GEN    (BX6 X1)              *   OUT PTR INTO X6
          GEN    (SX4 X4+B1)           *INCR OUT PTR BY 1 
          GEN    (BX7 X4)              *COPY IN X7
          GEN    (SA1 A4+B1)           *LIMIT PTR 
          GEN    (SX1 X1)              *KEEP LO 18 BITS 
          GEN    (IX1 X4-X1)           *TEST IF OUT=LIMIT 
          NEWLBL GRIMOVE1 
          GEN    (MI X1,"GRIMOVE1")    *IF OUT<LIMIT
          GEN    (SA1 A0+B1)           *FIRST PTR 
          GEN    (SX7 X1)              *SET OUT=FIRST (LO 18 BITS)
  
          GENLBL GRIMOVE1 
  
          GEN    (SA7 A4)              *UPDATE OUT PTR FOR *IN* 
  
                                       *SET RN FROM X5 INTO X6
          GEN    (MX0 1+1),B5          * MX0 1+1+LR 
          GEN    (BX6 -X0*X6)          *  RECORDS OF INTERNAL FILE
          SB7    -B5         -LR
          GEN    (LX5 60-1-1),B7       *LX5 -1-1-LR 
          GEN    (BX6 X5+X6)           *INSERT RN 
  
          GENLBL GRILBL3
          GEN    (SX2 B4)              *RESTORE X2 FROM B4
  
          EXIT
          END 
