*DECK S$GNVFY 
          IDENT  S$GNVFY
          TITLE  S$GNVFY - GENERATE VERIFY CODE 
          COMMENT  GENERATE VERIFY CODE 
          SPACE  4
*CALL LBLPTR
          ENTRY  S$GNVFY
*         CALLING SEQUENCE- 
*   S$GNVFY(REC$LK1,REC$LK2,SPEC$OUTFIT); 
* 
*         GIVEN-
*   REC$LK1 - NUMBER OF KEY BITS IN DESCRIPTOR
*   REC$LK2 - NUMBER OF KEY BITS (IF ANY) BEYOND DESCRIPTOR 
*   SPEC$OUTFIT - ADDRESS OF FIT OF OUTPUT FILE 
* 
*         DOES- 
*   GENERATES CODE
* 
*         GENERATED CODE DOES-
*   -SAVES REGISTERS IN S$VREGS 
*   -IMMEDIATELY RESTORES REGISTERS FROM SAME AREA
*   -CHECKS GLOBAL FLAG S$VFLAG 
*         -IF THIS FLAG = 1, IT MEANS THIS INPUT FILE 
*          HAS JUST BEEN OPENED AND THERE IS NO PREVIOUS RECORD 
*          FOR VERIFY TO COMPARE IT WITH
*         -IF THIS FLAG = 0, IT MEANS THAT COMPARISON IS NEEDED 
* 
*         SO, IF THIS FLAG = 1, WE MOVE THE RECORD JUST INVERTED
*         TO A PLACE CALLED S$VCURR ('CURRENT'), SET THE FLAG = 0,
*         AND EXIT. 
* 
*         IF FLAG = 0 - 
*           MOVE 'CURRENT' RECORD TO 'PREVIOUS' RECORD
*           MOVE RECORD JUST INVERTED TO 'CURRENT' RECORD 
*           COMPARE 'CURRENT' AND 'PREVIOUS'
*             - IF THEY ARE OUT OF ORDER, ISSUE A DIAGNOSTIC AND
*               ABORT THE SORT PROCESS
*             - OTHERWISE, RETURN 
* 
S$GNVFY   SUBR
  
*         SAVE PARAMETERS 
  
          SB1    1
          SA2    X1          VALUE OF REC$LK1 
          BX6    X2 
          SA6    HOLDLK1
          SA2    A1+B1       ADDRESS OF REC$LK2 
          SA3    X2          VALUE OF REC$LK2 
          BX6    X3 
          SA6    HOLDLK2
          SA3    A2+B1       ADDRESS OF SPEC$OUTFIT 
          SA3    X3 
          BX6    X3 
          SA6    HOLDFIT
  
  
          SX6    1           SET S$SVFLAG FOR VERY FIRST FILE 
          SA6    =XS$VFLAG
  
          GENLBL VERIFY 
          GENMAC (DATA 0)    ENTRY-EXIT WORD
  
  
          GENMAC  (VFD 12/0100B,18/=XSVR=,12/0,18/=XS$VREGS)
  
*         THAT IS SUPPOSED TO BE A GENERATED RJ TO SVR= 
  
          GEN    (SX1 =XS$VREGS)
          GEN    (RJ =XXJR=)
  
  
          GEN    (SA1 =XS$VFLAG)   CHECK FAMOUS FLAG
          NEWLBL VLBL1
          GEN    (BX0 X1)         SAVE S$VFLAG FOR LATER
          GEN    (NZ X1,"VLBL1")  DON'T VERIFY IF FLAG=1
  
* 
*  CODE TO MOVE 'CURRENT' TO 'PREVIOUS' 
* 
  
          GEN    (SA1 =XS$VCURR)   FIRST WORD OF 'CURRENT'
          GEN    (BX7 X1)          FIRST WORD OF 'PREVIOUS' 
          GEN    (SA7 =XS$VPREV)
  
          SA1    HOLDLK2
          SB3    X1          B3 = REC$LK2 
LBL1      IFTHEN B3>B0     IF KEY BITS EXIST IN FURTHER WORDS 
            SB3    B3-60   WE ARE COPYING 60 MORE BITS
            GEN    (SA1 A1+B1)
            GEN    (BX7 X1) 
            GEN    (SA7 A7+1) 
            EQ     LBL1 
            ENDIF.
  
          GENLBL  VLBL1      GET HERE IF NOT VERIFYING
  
* 
*  CODE TO MOVE CURRENT RECORD TO 'CURRENT' 
* 
  
***** 
* 
*  FIRST, MOVE KEYS FROM THE DESCRIPTOR TO WORD 1 OF S$VCURR
* 
***** 
          SA4    S$LR        FOR EXAMPLE, 12 BITS 
          SX4    X4+2        TWO BITS AT LEFT ARE NOT KEYS
*                            SO RESULT IS NOW 14
          GEN    (MX4 0),X4     MX4 LR+2
          GEN    (BX3 -X4*X6)   *X6 = CURRENT DESCRIPTOR
*                               *X3 = KEYS AND DATA NOW 
          SA5    HOLDLK1
          IX4    X4+X5       X4=16 BITS FOR RN + KEY BITS 
          GEN    (MX4 0),X4    *MX4 NUMBER OF KEY BITS IN *X6 
          GEN    (BX7 X3*X4)    *X7 = KEYS ONLY NOW 
          GEN    (SA7 =XS$VCURR)  SAVE THE KEYS IN WORD 1 
***** 
* 
*  NOW, MOVE ANY KEY BITS IN THE REMAINING WORDS
* 
***** 
  
          SA1    HOLDLK2     NO.OF KEY BITS BEYOND DESCRIPTOR 
          SB3    X1 
  
          IFTHEN  B3>B0 
            SA2    S$ORSA      X2 = ORSA
            SB2    X2          B2 = ORSA
  
            SA2    S$IRRL      X2 = IRRL
            SB3    X2          B3 = IRRL
            SB5    B2-B3       B5 = ORSA-IRRL 
  
            SA4    S$LR        X4 = LR
            BX5    -X4         X5 = -LR 
  
            GEN    (MX4 60),X5           (*X4 = MASK 60-LR) 
            GEN    (SX2 0),B3            (*X2 = IRRL) 
  
*         OBTAIN ADDRESS OF FIRST RSA WORD OF CURRENT RECORD
  
            GEN    (LX6 1+1),X4       *X6=DESCR.OF CURR. RECORD 
            GEN    (BX6 -X4*X6)          (*X6 = RECORD NUMBER)
            GEN    (IX6 X2*X6)           (*X6 = RN*IRRL)
            IFTHEN B5\0        IF ORSA >= IRRL
              GEN    (SX6 X6+0),B5         *SX6 X6+(ORSA-IRRL)
              ELSE- 
              GEN    (SX6 X6-0),B5         *SX6 X6-(IRRL-ORSA)
              ENDIF.
            GEN    (SB6 B2+X6)           (*B6 = ADDRESS)
            SA1    HOLDLK2
            SB3    X1 
            GEN    (SA1 B6-B1)      *GET READY TO LOOP
            GEN    (MX2 60)       *X2 = NORMALLY COMPLETE MASK
LBL2        GEN    (SA1 A1+B1)      *GET (ANOTHER) WORD 
            SB3    B3-60            *WE ARE MOVING 60 MORE BITS 
            IFTHEN    B3<B0 
              SB4    B3+60          B4 = NUMBER OF GOOD BITS IN *X1 
              GEN    (MX2 0),B4 
              ENDIF.
            GEN    (BX7 X1*X2)        *TRANSFER KEY BITS TO *X7 
            GEN    (SA7 A7+B1)        *STORE IN S$VCURR 
            IFTHEN    B3>B0           IF MORE KEY BITS TO MOVE
              EQ LBL2 
              ENDIF.
            ENDIF.
  
  
          GEN    (MX6 0)
          GEN    (SA6 =XS$VFLAG)    RESET FLAG TO ZERO
  
  
  
  
          NEWLBL  VLBLF 
          GEN    (NZ X0,"VLBLF")      QUIT IF NOT VERIFYING 
  
* 
* CODE TO COMPARE 'CURRENT' AND 'PREVIOUS'
* 
  
          NEWLBL VLBLE
  
  
          GEN    (SA2 =XS$VCURR)    GET FIRST WORD OF 'CURRENT' 
          GEN    (SA3 =XS$VPREV)    GET FIRST WORD OF 'PREVIOUS'
          GEN    (IX3 X2-X3)        COMPARE -'PREVIOUS' SHD BE SMALLER
  
          GEN    (NG X3,"VLBLE")
          GEN    (NZ X3,"VLBLF")
  
*  IF WE GET HERE, THE KEYS WERE EQUAL
  
          SA1    HOLDLK2
          SB3    X1 
LBL3      IFTHEN    B3>B0      IF MORE BITS REMAIN TO COMPARE 
            SB3    B3-60
            GEN    (SA2 A2+B1)    GET NEXT WORD OF 'CURRENT'
            GEN    (SA3 A3+B1)    GET NEXT WORD OF 'PREVIOUS' 
            GEN    (IX3 X2-X3)
            GEN    (NG X3,"VLBLE")    BAD COMPARE 
            GEN    (NZ X3,"VLBLF")   GOOD COMPARE 
            EQ    LBL3
            ENDIF.
  
          GENLBL VLBLF       EXIT VERIFY PROCESSING 
  
  
          GEN    (SX1 =XS$VREGS)
          GEN    (RJ =XXJR=)
  
          GEN    (EQ "VERIFY")
  
          GENLBL VLBLE
  
* WE GET HERE IF THINGS GO WRONG
          NEWLBL SAVEX2 
          GENLBL SAVEX2 
          GENMAC (DATA -0)
          GEN    (SX6 A0) 
          GEN    (SA6 "SAVEX2") 
          SA1    HOLDFIT
          SB3    X1 
          GEN    (SA0 0),B3 
          NEWLBL NEXT 
          GEN    (SB6 "NEXT") 
 #HAVEB6  SET    1
          GENMAC (CLOSEM A0,DET)
          GENLBL NEXT 
          GEN    (SA2 "SAVEX2") 
          GEN    (SA0 X2) 
          GEN    (CALL S$VABT)
          EXIT
  
  
 S$IRRL   EXTERNAL           NUMBER OF WORDS PER SLOT IN THE RECORD 
                              STORAGE AREA  (I.E. REC$IRRL) 
 S$LK     EXTERNAL           NUMBER OF BITS OF INFORMATION THAT HAVE
                              BEEN PREVIOUSLY APPENDED
 S$LR     EXTERNAL           NUMBER OF BITS RESERVED FOR RECORD NUMBER
                              (REC$LR)
 S$ORSA   EXTERNAL           WORD OFFSET WITHIN WSA$ OF RECORD
                              STORAGE AREA  (WSAS$ORSA) 
  
HOLDLK1   DATA   0
  
HOLDLK2   DATA   0
  
HOLDFIT   DATA   0
  
          END 
