*DECK S$GNGIV 
          IDENT  S$GNGIV
          TITLE  S$GNGIV -  GENERATE- GET INTERNAL VARIABLE-LENGTH RECORD 
          COMMENT  GENERATE- GET INTERNAL VARIABLE-LENGTH RECORD
  
*CALL LBLPTR
  
          SPACE  4
**        S$GNGIV -  GENERATE- GET INTERNAL VARIABLE-LENGTH RECORD
* 
*     CALLING SEQUENCE: 
*         S$GNGIV(REC$LR, OFFSET, LL, REC$IRRL, LF);
* 
*     GIVEN:  
*         REC$LR = NUMBER OF BITS TO HOLD RECORD NUMBER 
*         OFFSET = BIT OFFSET TO BEGINNING OF LENGTH FIELD
*                  (I.E. 1+1+LR+LK+LO)
*         LL = LENGTH OF LENGTH FIELD 
*              (I.E. REC$LL1 + REC$LL2) 
*         REC$IRRL = NUMBER OF WORDS BEYOND DESCRIPTOR
*         LF = LENGTH OF NON-KEY, NON-SUM FIXED PART OF RECORD
*              (I.E. REC$LF1 + REC$LF2) 
* 
*     DOES: 
*         GENERATES CODE. 
* 
*     GENERATED CODE EXPECTS: 
*         "SAVEAD" = ADDRESS FOR REST OF RECORD 
*         *A0 = ADDRESS OF FET OF INTERNAL FILE 
*         *X2 = INDEX TO TOURNAMENT 
*         *X5 = RECORD NUMBER FOR NEW RECORD
* 
*     GENERATED CODE DOES:  
*         TRIES TO READ AN INTERNAL RECORD FROM THE FILE VIA *A0. 
*         IF SUCCESSFUL,
*             SETS *X6 WITH DESCRIPTOR
*             SETS RSA WITH REST OF RECORD VIA "SAVEAD" 
*         ELSE,  (IF END-OF-DATA) 
*             SETS *X6 = 0
* 
*     GENERATED CODE USES:  
*         *B    * * 3 4 5 6 7    *B1=1, *B2=WSA$
*         *X  0 1 * 3 4 5 6 7    *(RIGHT 18 BITS PRESERVED) 
*         *A  - 1 2 3 4 5 6 7 
  
  
          ENTRY  S$GNGIV
 S$GNGIV  SUBR
          SB1    1           CONSTANT 1 
  
*     GET PARAMETERS
  
          SA2    A1          ADDRESS OF REC$LR
          SA2    X2          VALUE OF REC$LR
          SB5    X2          B5 = REC$LR
          SA2    A1+B1       ADDRESS OF OFFSET
          SA2    X2          VALUE OF OFFSET
          SB2    X2          B2 = OFFSET
          SA2    A1+2        ADDRESS OF LL
          SA2    X2          VALUE OF LL
          SB3    X2          B3 = LL
          SA2    A1+3        ADDRESS OF REC$IRRL
          SA5    X2          X5 = REC$IRRL
          SA2    A1+4        ADDRESS OF LF
          SA2    X2          VALUE OF LF
          BX6    X2 
          SA6    LF          *LF* := VALUE OF LF
  
          GEN    (SB6 X2)              *PRESERVE INDEX TO TRN IN *B6
         *USES   X0,AX1-3,AX6,B6,B7 
          GEN    (SB5 X5)              *PRESERVE RECORD NUMBER IN *B5 
  
          NEWLBL GETWORD
          GEN    (RJ "GETWORD")        *SET X6 = NEXT WORD, ELSE "GRIMOVE4" 
          GEN    (LX6 1+1+0),B5        *LX6 1+1+LR
          SB6    60 
          SB7    B6-B5       60-LR
          GEN    (MX0 0),B7 
          GEN    (BX6 X0*X6)           *CLEAR RN FIELD
          GEN    (SX5 B5) 
          GEN    (BX6 X6+X5)           *INSERT NEW RN 
          SB7    1+1+B5      1+1+LR 
          SB6    60 
          SB7    B6-B7
          GEN    (LX6 0),B7 
          IFTHEN X5"0        IF MORE WORDS
            NEWLBL DESCRIP
            GEN    (SA6 "DESCRIP")
            SX2    B2          OFFSET 
            SX0    1S22/60+1   1/60 * 2**22 
            IX4    X0*X2       OFFSET/60 * 2**22
            AX4    22          OFFSET/60
            SX0    60 
            IX5    X0*X4       (OFFSET/60)*60 
            IX5    X2-X5       OFFSET - (OFFSET/60)*60 = BIT OFFSET 
            GEN    (SB2 0),X4 
            GEN    (SB3 B0) 
            GEN    (SA1 "SAVEAD")      *ADDRESS FOR REST OF RECORD
            GEN    (SB4 X1)            *PRESERVE IN *B4 
            IFTHEN X4"0 
              NEWLBL NEXT 
              GENLBL NEXT 
              GEN    (RJ "GETWORD")    *X6 = NEXT WORD, ELSE "GRIMOVE4" 
              GEN    (SA6 B4+B3)       *STORE IN RSA
              GEN    (SB3 B3+B1)       *INCREMENT COUNT 
              GEN    (NE B3,B2,"NEXT") *IF MORE, LOOP 
              ENDIF.
            GEN    (BX5 X6)            *COPY WORD WITH LENGTH FIELD 
            SB7    X5+B3        OFFSET + LL 
            SB6    60 
            IFTHEN B7@B6      IF FIELD ENTIRELY IN *X5
              GEN    (LX5 0),B7        *RIGHT-JUSTIFY FIELD 
              SB6    60 
              SB7    B6-B3       60-LL
              GEN    (MX0 0),B7 
              GEN    (BX5 -X0*X5)      *X5 HAS LENGTH 
            ELSE-            IF FIELD SPANS TWO WORDS 
              SB6    60 
              SB7    X5          OFFSET 
              GEN    (MX0 0),B7 
              GEN    (BX5 -X0*X6) 
              GEN    (BX7 X5)    PRESERVE *X5 IN *X7
              GEN    (RJ "GETWORD")    *X6 = NEXT WORD, ELSE "GRIMOVE4" 
              GEN    (BX5 X7)    RESTORE *X5
              GEN    (SA6 B4+B3)       *STORE IN RSA
              GEN    (SB3 B3+B1)       *INCREMENT COUNT 
              SB7    X5+B3       OFFSET+LL
              SB7    B7-60
              GEN    (MX0 0),B7 
              GEN    (BX6 X0*X6)
              GEN    (BX5 X6+X5)
              SB7    X5+B3       OFFSET+LL
              SB7    B7-60
              GEN    (LX5 0),B7        *RIGHT-JUSTIFY LENGTH
              ENDIF.
                               *X5 HAS LENGTH FIELD 
            SB7 B2+B3          OFFSET + LL
            SA1    LF 
            SX1 X1+B7 
            GEN    (SX2 0),X1  *OFFSET + LL + LF
            GEN    (SX0 6)
            GEN    (IX5 X5*X0) *VARIABLE LENGTH IN BITS 
            GEN    (IX5 X5+X2) *TOTAL LENGTH OF THIS RECORD IN BITS 
            GEN    (SX1 1S22/60+1)
            GEN    (IX2 X5*X1)
            GEN    (AX2 22)    *TOTAL LENGTH OF RECORD IN WORDS 
            GEN    (SB2 X2)    *B2 := RECLEN IN WORDS 
            NEWLBL NEXT2
            GEN    (EQ B3,B2,"NEXT2")  *IF ALREADY DONE, SKIP 
            NEWLBL NEXT 
            GENLBL NEXT 
            GEN    (RJ "GETWORD")      *SET X6 = NEXT WORD, ELSE "GRIMOVE4" 
            GEN    (SA6 B4+B3)         *STORE IN RSA
            GEN    (SB3 B3+B1)         *INCREMENT WORD COUNT
            GEN    (NE B3,B2,"NEXT")   *IF MORE WORDS, LOOP 
            GENLBL NEXT2
            GEN    (SA1 "DESCRIP")
            GEN    (BX6 X1) 
            ENDIF.
          NEWLBL GRIMOVE4 
          GEN    (EQ "GRIMOVE4")       *SKIP "GETWORD"
  
*    GENERATE "GETWORD" 
  
*         GIVEN:  *A0 = ADDRESS OF FET
*         DOES:   IF ANYTHING LEFT ON FILE, 
*                     SETS *X6 = WORD 
*                 ELSE, 
*                     SETS *X6 = 0
*                     JUMPS TO "GRIMOVE4" 
  
          GENLBL GETWORD
          GENMAC (DATA -0)
          NEWLBL GRIMOVE1 
          GENLBL GRIMOVE1 
          GEN    (SA2 A0+2)            *IN
          GEN    (SA3 A2+B1)           *OUT 
          GEN    (IX0 X2-X3)           *IN VS. OUT
          NEWLBL GRIMOVE2 
          GEN    (ZR X0,"GRIMOVE2")    *IF EMPTY BUFFER, SKIP 
          GEN    (SA5 X3)              *WORD AT (OUT) 
          GEN    (SX6 X3+B1)           *OUT := OUT + 1
          GEN    (SA6 A3) 
          GEN    (SA4 A3+B1)           *LIMIT 
          GEN    (SX4 X4)              *KEEP ONLY RIGHT 18 BITS 
          GEN    (IX0 X6-X4)           *OUT VS. LIMIT 
          GEN    (BX6 X5)              *RESULT WORD 
          GEN    (NZ X0,"GETWORD")     *IF NO WRAP-AROUND, EXIT 
          GEN    (SA1 A0+B1)           *FIRST 
          GEN    (SX1 X1)         *KEEP LOW 18 BITS 
          GEN    (SX6 X1)              *OUT := FIRST
          GEN    (SA6 A6) 
          GEN    (BX6 X5)              *RESULT WORD 
          GEN    (EQ "GETWORD") 
          NEWLBL HOLDX7 
          GENLBL HOLDX7 
          GENMAC (DATA 0) 
  
          GENLBL GRIMOVE2              *BUFFER IS EMPTY 
          GEN    (SA7 "HOLDX7") 
          GEN    (SA1 A0)              *42/LFN, 18/CODE+STATUS
          GEN    (MX0 -6) 
          GEN    (BX1 -X0*X1)          *RIGHT 6 BITS
          GEN    (SX0 X1-21B)          *EOR 
          GEN    (MX6 0)               *NOTE END-OF-DATA
          GEN    (ZR X0,"GRIMOVE4")    *IF END-OF-RECORD, JUMP
          GENMAC (READ A0,RECALL)      *READ DATA OR END-OF-RECORD
          GEN    (SA2 "HOLDX7") 
          GEN    (BX7 X2) 
          GEN    (EQ "GRIMOVE1")       *GO TRY AGAIN
  
  
          GENLBL DESCRIP
          GENMAC (DATA -0)
  
          GENLBL GRIMOVE4              *GOT INTERNAL RECORD 
  
          NEWLBL   NEXT 
          GEN   (ZR X6,"NEXT")    DO NOT DESTROY EOD
          GEN    (MX0 1+1),B5          *MX0 1+1+LR
          GEN    (BX6 -X0*X6)          *  RECORDS OF INTERNAL FILE
          GEN    (SX2 B5)              *X2= RN
          SB7    -B5         -LR
          GEN    (LX2 60-1-1),B7       *LX2 -1-1-LR 
          GEN    (BX6 X2+X6)           *INSERT RN 
          GENLBL   NEXT 
  
          GEN    (SA1 "WSA")
          GEN    (SB2 X1)              *RESTORE ORIGINAL *B2
          GEN    (SX2 B6)              *RESTORE ORIGINAL *X2
          EXIT
  
  
 LF       BSS    1           REC$LF1 + REC$LF2
  
  
          END 
