*DECK S$GNLG4 
          IDENT  S$GNLG4
          TITLE  S$GNLG4  - GENERATE LONG CODE PART 4 
          COMMENT  GENERATE LONG CODE PART 4. 
  
*CALL LBLPTR
  
*CALL LSTRTBL 
  
  
          B1=1
  
  
**        S$GNLG4  - GENERATE LONG CODE PART 4
* 
* 
*     CALLING SEQUENCE- 
*         S$GNLG4;
* 
*     DOES- 
*         GENERATE LONG CODE PART 4 
* 
*         GENERATED CODE EXPECTS- 
*         X7<0 IF CR(IN X6 > LL(IN X4)
* 
*         GENERATED CODE DOES-
*         IF CR AND LL ON SAME STRING,
*             IF CR > LL, SWAP CR AND LL THEN GOTO NEXT LEVEL 
*         IF CR AND LL ON DIFFERENT STRINGS,
*             IF LL ON CURRENT STRING, SWAP CR AND LL, GOTO NEXT LEVEL
*         IF LEVEL 0 REACHED, WE HAVE A WINNER
*         IF WINNER ON CURRENT STRING, SWITCH "NEXTSTR" FLAG
*         IF STRTBL$ IS FULL, WRITE ITS ENTRIES TO FILE ZZZZZ3Z 
*         ENTER STRING DESCR TO STRTBL$  18/STRORD,12/FILENO,30/0 
*         IF FILE NO=52 (I.E. LFN=ZZZZZ2Z), 
*             RESET FILE NO TO 0 AND INCREMENT STRING ORDINAL 
*         SET UP NEW STRING LFN 
*         RETRIEVE CR(X6) 
*         IF WINNER"EOD, GOTO "LONG2" 
*             ELSE DONE, EXIT LONG-CODE 
* 
  
  
          ENTRY  S$GNLG4
 S$GNLG4  SUBR               ENTRY/EXIT WORD
          SB1    1           CONSTANT 1 
  
* GENERATE CODE EXPECTS X7 TO BE NEGATIVE IF CR(IN X6) > LL(IN X4)
* 
          GEN    (NG X7,"LONG6")       *IF CR>LL
          GEN    (EQ "LONG7")          * OTHERWISE
          GENLBL LONG5
          GEN    (SA3 "NEXTSTR")       *BIT INDICATING NEXT STRING
          GEN    (BX3 X3-X6)           *EXAMINE STRING FLAG OF CR 
          GEN    (NG X3,"LONG7")       *IF DIFFERENT,CR IS ON CURRENT STRING
          GENLBL LONG6
          GEN    (SA6 A4)              *SWAP CR 
          GEN    (BX6 X4)              *  AND LL
          GENLBL LONG7
          GEN    (AX2 1)               *GOTO NEXT LEVEL 
          GEN    (NZ X2,"LONG4")       *IF NOT LEVEL 0
          NEWLBL NEXT 
          GEN    (ZR X6,"NEXT")        *IF WINNER=EOD,SKIP
* 
* CHECK IF NEW RECORD ON CURRENT STRING 
          GEN    (SA5 "NEXTSTR")
          GEN    (BX3 X5-X6)
          GEN    (NG X3,"LONG2")       *IF REC ON CURRENT STRING
* 
* SWITCH NEXT STRING FLAG 
          GEN    (SA5 "NEXTSTR")
          GEN    (MX7 1)
          GEN    (BX7 X7-X5)
          GEN    (SA7 A5) 
* 
          GENLBL NEXT 
* WRITE OUT REST OF BUFFER
          GEN    (SA6 "RECDESC")       *SAVE CR(X6) 
          GEN    (SA0 "FET")
  
          NEWLBL NEXT 
          GEN    (SA1 6+"FET")  *CHECK IF CIO WRITE PERFORMED 
          GEN    (SX1 X1) 
          GEN    (ZR X1,"NEXT")     *SKIP CIO WRITE IF ALREADY DONE 
          GENMAC (WRITE A0,RECALL)
          GENLBL NEXT 
          GEN    (SX7 "STRORD2")
          GEN    (SA7 A0+6) 
  
          IFNOS 
          GENMAC (WRITER A0,RECALL) 
          ELSE
          GENMAC (WRITER A0,,RECALL)
          ENDIF 
  
* 
* SAVE STRING DESCRIPTOR
  
          GEN    (SA1 "STRORD")        *X1=START PRU NO 
          GEN    (SA2 "STRORD2")
          GEN    (IX7 X2-X1)           *X7=STRING LEN IN PRU
  
          NEWLBL NEXT 
          GEN    (MX2 17) 
          GEN    (LX2 17)        *MAXIMUM NUMBER OF PRUS IN 18 BITS 
          GEN    (IX4 X7-X2)
          GEN    (NG X4,"NEXT")  *IF NPRUS <= MAXIMUM 
          GEN    (SX7 X2)        *NPRUS := MAX
          GENLBL NEXT 
          GEN    (LX1 30)              *X1=30/STRORD,30/0 
          GEN    (BX7 X1+X7)           *X7=30/STRORD,30/NPRUS 
          GEN    (SA2 "FILENUM")
          GEN    (LX2 18) 
          GEN    (BX7 X7+X2)           *X7=20/STRORD,12/FILENO,18/NPRUS 
  
          GEN    (SA4 "STRTBL")        *X4 = ADDR OF STRTBL$
          GEN    (SA4 X4)              *X4 = STRTBL$LEN 
          GEN    (SA3 "NWRITTN")       *NO STRING DESC. WRITTEN 
          GEN    (SB3 A4)              *ADDR OF STRTBL$ 
          GEN    (SA7 B3+X3)           *ENTER ENTRY INTO STRTBL$
  
* TEST IF STRTBL$ FULL THEN WRITE TO FILE ZZZZZ3Z 
  
          GEN    (SX0 LSTRTBL-1)       *MULTIPLES OF PRUS 
  
          NEWLBL TBNOTFUL 
          GEN    (IX2 X3-X0)           *TEST NWRITTN AGAINST LSTRTBL
          GEN    (MI X2,"TBNOTFUL")    *IF STRTBL$ NOT FULL 
* 
* WRITE STRTBL$ WORD 1-LSTRTBL TO FILE ZZZZZ3Z
* 
          GEN    (SA0 "FET3Z")
          GEN    (SA1 A0+B1)           *FIRST PTR IN FET
          GEN    (SX7 X1+LSTRTBL)      *SET IN=FIRST+LSTRTBL
          GEN    (SA7 A1+B1)           *CIO STOPS WRITING AT FIRST+LSTRTBL-1
          GEN    (SX7 X1)         *KEEP LOW 18 BITS 
          GEN    (SA7 A7+B1)           *OUT = FIRST 
  
          GEN    (MX7 1)               *MARK THAT PART OF 
          NEWLBL SHORT
          GEN    (SA7 "SHORT")         *  STRTBL$ ON FILE ZZZZZ3Z 
  
          GENMAC (WRITE A0,RECALL)
  
* INCREMENT STRTBL$LEN BY LSTRTBL 
  
          GEN    (IX7 X4+X0)           *STRTBL$LEN + LSTRTBL -1 
          GEN    (SA7 A4)              *UPDATE STRTBL$ WORD 0 
  
          GEN    (MX3 0)               *RESET NWRITTN TO 0
  
          GENLBL TBNOTFUL 
          GEN    (SX3 X3+B1)           *INCREMENT NWRITTN 
          GEN    (BX7 X3) 
          GEN    (SA7 A3)              *UPDATE NWRITTN
  
* 
* TEST FOR MAX N0 OF FILES
          GEN    (SA2 "FILENUM")       *RIGHT JUSTIFY FILE NO 
          GEN    (SX7 X2+B1)           *FILENUM + 1 
          GEN    (SX3 15)              *TEST IF LFN IN RANGE
          GEN    (IX3 X7-X3)           *  ZZZZZ1A-ZZZZZ1M 
          NEWLBL LONG8
          GEN    (NG X3,"LONG8")       *IF LFN <= ZZZZZ1M 
  
                                       *CASE LFN > ZZZZZ1M
          GEN    (SX7 B1)              *RESET FILENUM TO 1
  
          GENLBL LONG8
          GEN    (SA7 A2)              *UPDATE FILENUM
* 
* SET UP NEW STRING LFN FROM FILENUM
          GEN    (SA1 "FET1A")         *X1=36/ZZZZZ1,24/1 
          GEN    (SX2 27)              *TEST IF 
          GEN    (IX2 X7-X2)           *   LFN>=ZZZZZ1Z 
          NEWLBL LONG9
          GEN    (NG X2,"LONG9")       *IF LFN<ZZZZZ1Z
          GEN    (SX7 X2+B1)           *X7=FILENUM-26 
          GEN    (MX0 1)
          GEN    (LX0 25)              *SHIFT TO 6TH CHAR.
          GEN    (IX1 X1+X0)           *CHANGE ZZZZZ1 TO ZZZZZ2 
  
          GENLBL LONG9
          GEN    (LX7 18)              *SHIFT FILENUM TO 7TH CHAR 
          GEN    (BX7 X1+X7)           *SET 7TH CHAR OF LFN 
          GEN    (SA7 "FET")           *SET FET WITH NEW LFN
          GEN    (SX7 "STRORD")        *ADDR TO SAVE START PRU NO 
          GEN    (SA7 A7+6)            *WORD 6 OF FET 
  
          GEN    (SA2 "RECDESC")       *RETRIEVE CR(X6) 
          GEN    (BX6 X2) 
          GEN    (NZ X6,"LONG2")       *IF WINNER"EOD 
  
* 
* TEST IF PART OF STRTBL$ ALREADY ON FILE ZZZZZ3Z,
*   THEN WRITE THEN REST OF STRTBL$ TO FILE.
* 
          GEN    (SA1 "SHORT")         *X1 <> 0 IF ZZZZZ3Z USED 
          NEWLBL NEXT 
          GEN    (ZR X1,"NEXT")        *IF NOT USED, EXIT 
  
* 
* WRITE REST OF STRTBL$ TO FILE ZZZZZ3Z 
* 
          GEN    (SA0 "FET3Z")
          GEN    (SA1 A0+B1)           *FIRST PTR IN FET
          GEN    (SX1 X1)         *KEEP LOW 18 BITS 
          GEN    (SA3 "NWRITTN")       *NO STRING DESC. WRITTEN 
          GEN    (IX7 X1+X3)           *FIRST + NWRITTN 
          GEN    (SX7 X7-1) 
          GEN    (SA7 A1+B1)           *IN = FIRST+NWRITTN-1
          GEN    (BX7 X1) 
          GEN    (SA7 A7+B1)           *OUT = FIRST 
  
          GENMAC (WRITER A0,RECALL)    *EMPTY ZZZZZ3Z BUFFER
          GENMAC (REWIND A0,RECALL)    *REWIND ZZZZZ3Z FOR S$MGDSN
  
          GENLBL NEXT 
          GEN    (SA1 "STRTBL")        *X1=ADDR OF STRTBL$
          GEN    (SA2 X1)              *X2=STRTBL$LEN 
  
          GEN    (SA3 "NWRITTN")
          GEN    (SX3 X3-1)            * -1 SINCE WE START W/ 1 
          GEN    (IX7 X2+X3)           STRTBL$LEN = 
          GEN    (SA7 X1)                 STRTBL$LEN + NWRITTN
  
  
          GEN    (EQ "LONG1")          *EXIT LONG-CODE
  
  
          GENLBL SHORT                 *0 IF ZZZZZ3Z NOT USED 
          GENMAC (DATA 0) 
          GENMAC (DATA -0)             *DUMMY WD AT END OF CODE 
  
          EXIT
          END 
