*DECK S$GNRD
          PROC S$GNRD(KEYOFFSET, KEYLENGTH, ASC, CS); 
  
#**       S$GNRD -  GENERATE CODE TO REVERT A DISPLAY FIELD            #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GNRD(KEYOFFSET, KEYLENGTH, ASC, CS)                        #
#                            =(S$IRRL, S$LK, S$LR, S$OREC, S$ORSA)=    #
#                                                                      #
#     GIVEN-                                                           #
#         KEYOFFSET = BIT OFFSET OF LEFT-MOST BIT IN EXTERNAL FIELD.   #
#          THE FIRST BIT OF THE RECORD IS BIT NUMBER 0.                #
#         KEYLENGTH = NUMBER OF BITS IN THE EXTERNAL FIELD.            #
#         ASC = TRUE IF SORT ORDER IS ASCENDING                        #
#         CS = ADDRESS OF FIRST WORD OF WEIGHT TABLE                   #
#         S$IRRL = NUMBER OF WORDS PER SLOT IN THE RECORD STORAGE AREA.#
#         S$LK = NUMBER OF BITS RESERVED FOR RECORD NUMBER.            #
#         S$OREC = WORD OFFSET WITHIN WSA$ FOR EXTERNAL RECORD.        #
#         S$ORSA = WORD OFFSET WITHIN WSA$ OF RECORD STORAGE AREA.     #
#                                                                      #
#     DOES-                                                            #
#         GENERATES CODE.                                              #
#         INCREMENTS S$LK BY THE LENGTH OF THIS INTERNAL FIELD.        #
  
          BEGIN 
  
          XREF
              BEGIN 
              ITEM S$LK I;
              PROC S$GNRD1; 
              END 
  
          ITEM  KEYOFFSET    I; 
          ITEM  KEYLENGTH    I; 
          ITEM  ASC          B; 
          ITEM  CS           I; 
          BASED ARRAY BA [0:63];
              BEGIN 
              ITEM A  I(0,52,8);
              END 
  
          ARRAY RVTABLE[0:63];
              BEGIN 
              ITEM RVT U(0,0,60); 
              END 
  
          ARRAY TEMP [0:63];
              BEGIN 
              ITEM TMP  U(0,0,60);
              END 
  
  
          ITEM I; 
          ITEM EQUATES B; 
          ITEM ALTER B; 
  
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
CONTROL EJECT;
  
#     IF THE COLLATING SEQUENCE HAS EQUATES AND NO ALTER,              #
#         RETURN (SINCE THE ORIGINAL CHARACTERS ARE STILL THERE)       #
  
          P<BA> = CS; 
  
          # INITIALIZE REVERSION TABLE TO CONSTANT -1                  #
  
          FOR I = 0 STEP 1 UNTIL 63 DO
              RVT[I] = -1;
  
          ALTER = FALSE;
  
  
          FOR I = 0 STEP 1 UNTIL 63 DO
              BEGIN 
              # CHECK TO SEE IF ANY ITEMS IN THE WEIGHT                #
              # TABLE HAVE THE HIGH BIT TURNED ON, WHICH               #
              # INDICATES A "MASTER CHARACTER" FOR USE WITH            #
              # THE "ALTER" OPTION. IF THIS BIT IS TURNED              #
              # ON, THE NUMBER WILL BE GREATER THAN 63.                #
  
              IF A[I] LQ 63 THEN
                  BEGIN 
                  # CHECK TO MAKE SURE THAT THE ENTRY IS               #
                  # STILL -1 -- IT MAY HAVE BEEN REPLACED              #
                  # WITH A "MASTER CHARACTER" IN THE LOOP              #
                  # BELOW              #
  
                  IF RVT[A[I]] EQ -1 THEN 
                      RVT[A[I]] = I;
                  END 
              ELSE
                  BEGIN 
                  # "ALTER" HAS BEEN SPECIFIED, SO SUBTRACT 64         #
                  # TO TURN OFF THE HIGH ORDER BIT                     #
  
                  ALTER = TRUE; 
                  RVT[A[I]-64] = I; 
                  END 
              END 
  
          EQUATES = FALSE;
          FOR I = 0 STEP 1 UNTIL 63 DO
              BEGIN 
              IF RVT[I] EQ -1 THEN
                  EQUATES = TRUE; 
              END 
  
          IF EQUATES AND NOT ALTER THEN 
              BEGIN 
              END 
  
#     IF DESCENDING,                                                   #
#         REVERSE THE ORDER OF THE REVERT-TABLE                        #
  
          IF NOT ASC THEN 
              BEGIN 
              FOR I = 0 STEP 1 UNTIL 63 DO
                  TMP[I] = RVT[I];
  
              FOR I = 0 STEP 1 UNTIL 63 DO
                  RVT[I] = TMP[63-I]; 
  
              END 
  
#     GENERATE REVERSION CODE                    #
  
          S$GNRD1(KEYOFFSET, KEYLENGTH, RVTABLE); 
                                  #(S$IRRL, S$LK, S$LR, S$OREC, S$ORSA)#
  
          END # S$GNRD #
          TERM
