*DECK S$GNSRT 
          PROC  S$GNSRT(REC$, SPEC$, CODE$);
  
#**       S$GNSRT -  GENERATE CODE FOR SORT PHASE                      #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GNSRT(REC$, SPEC$, CODE$):                                 #
#                                                                      #
#     GIVEN-                                                           #
#         REC$ = FORMAT OF INTERNAL RECORD.                            #
#         SPEC$ = USER SPECIFICATION AS IN COMDECK SPEC$.              #
#         CODE$ = AREA FOR GENERATED CODE AS IN CODE$.                 #
#                                                                      #
#     DOES-                                                            #
#         PUTS CODE$ TERMED "SHORT-CODE" AND "LONG-CODE" ON            #
#          A FILE ACCESSIBLE BY S$SETCD.                               #
#         SETS CODE$ TO CODE TERMED "INIT-CODE".                       #
#         SHRINKS THE SIZE OF CODE$ TO THE LARGEST OF ALL THE VARIOUS  #
#          CODE BLOCKS GENERATED.                                      #
#                                                                      #
#     NOTE-                                                            #
#         IN ORDER TO AVOID EXCESSIVE PARAMETER PASSING TO THE CODE    #
#          GENERATION ROUTINES S$GEN AND S$GNLBL CERTAIN VARIABLES     #
#          ARE DEFINED HEREIN THAT THESE TWO ROUTINES REFERENCE        #
#          DIRECTLY.                                                   #
  
  
          BEGIN 
  
*CALL A 
  
*CALL CODE$ 
  
*CALL REC$
  
*CALL SPEC$ 
  
*CALL WSAS$ 
  
          XREF
              BEGIN 
              PROC  S$CMSLF;           # SHRINK MEMORY BLOCK AT LWA    #
              PROC  S$ALCS;            # ALLOCATE WSAS$                #
              PROC  S$GNINI;           # GENERATE INIT-CODE            #
              PROC  S$GNLNG;           # GENERATE LONG-CODE            #
              PROC  S$GNSHT;           # GENERATE SHORT-CODE           #
              PROC  S$INITL;           # INITIALIZE LABELS             #
              PROC  S$LOAD;            # LOAD A CAPSULE                #
              PROC  S$SAVCD;           # SAVE CODE$ ON A FILE          #
              PROC  S$ULOAD;           # UNLOAD A CAPSULE              #
              ITEM  S$LOC    I;        # ABSOLUTE ADDRESS FOR NEXT INST#
              ITEM  S$POS    I;        # NEXT FREE BIT FOR INST, 0=LEFT#
              ITEM  S$ACODE  I;        # ABS. ADDRESS OF FIRST CODE WD #
              ITEM  S$LCODE  I;        # LENGTH OF CODE$               #
              END 
  
          ITEM  MAXCODEUSED  I;        # MAXIMUM OF ALL CODE$USED      #
          ITEM  UNUSED       I;        # PARAMETER TO S$CMSLF          #
  
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
CONTROL EJECT;
  
#     ALLOCATE WORKING STORAGE AREA FOR INIT-CODE,SHORT-CODE,LONG-CODE #
  
          S$ALCS(SPEC$, REC$, WSAS$);  # SET WSAS$                     #
  
#     PREPARE TO CALCULCATE MAXIMUM CODE USED                          #
  
          MAXCODEUSED = 0;
  
#    GENERATE LONG CODE FIRST                                          #
  
          S$LOAD("S$GNGRU");
  
          S$INITL;                     # INITIALIZE LABELS             #
          S$ACODE = LOC(CODE$WORD[1]);           # FOR S$GEN, S$GNLBL  #
          S$LCODE = CODE$LENGTH;                 # FOR S$GEN           #
          S$LOC = S$ACODE;                       # FOR S$GEN, S$GNLBL  #
          S$POS = 0;                             # FOR S$GEN, S$GNLBL  #
          S$LOAD("S$GNLNG");                     # LOAD PROC S$GNLNG   #
          S$GNLNG(SPEC$, WSAS$, REC$);           # CODE$ = LONG-CODE   #
          S$ULOAD("S$GNLNG");                    # UNLOAD PROC S$GNLNG #
          CODE$USED = S$LOC - S$ACODE +2;  # (+2 FOR SAFETY)           #
          IF CODE$USED GR MAXCODEUSED THEN
              MAXCODEUSED = CODE$USED;
          S$SAVCD(CODE$, "LONG-CODE");           # SAVE CODE$ ON FILE  #
  
#     GENERATE SHORT-CODE                                              #
          S$ULOAD("S$GNGRU"); 
          S$LOAD("S$GNPRU");
  
  
          S$INITL;                     # INITIALIZE LABELS             #
          S$ACODE = LOC(CODE$WORD[1]);           # FOR S$GEN, S$GNLBL  #
          S$LCODE = CODE$LENGTH;                 # FOR S$GEN           #
          S$LOC = S$ACODE;                       # FOR S$GEN, S$GNLBL  #
          S$POS = 0;                             # FOR S$GEN, S$GNLBL  #
          S$LOAD("S$GNSHT");                     # LOAD PROC S$GNSHT   #
          S$GNSHT(SPEC$, WSAS$, REC$);           # CODE$ = SHORT-CODE  #
          S$ULOAD("S$GNSHT");                    # UNLOAD PROC S$GNSHT #
          CODE$USED = S$LOC - S$ACODE +2;  # (+2 FOR SAFETY)           #
          IF CODE$USED GR MAXCODEUSED THEN
              MAXCODEUSED = CODE$USED;
          S$SAVCD(CODE$, "SHORT-CODE");          # SAVE CODE$ ON FILE  #
  
#     GENERATE INIT-CODE                                               #
          S$ULOAD("S$GNPRU"); 
          S$LOAD("S$GNGRU");
  
  
          S$INITL;                     # INITIALIZE LABELS             #
          S$ACODE = LOC(CODE$WORD[1]);           # FOR S$GEN, S$GNLBL  #
          S$LCODE = CODE$LENGTH;                 # FOR S$GEN           #
          S$LOC = S$ACODE;                       # FOR S$GEN, S$GNLBL  #
          S$POS = 0;                             # FOR S$GEN, S$GNLBL  #
          S$LOAD("S$GNINI");                     # LOAD PROC S$GNINI   #
          S$GNINI(SPEC$, WSAS$, REC$);           # CODE$ = INIT-CODE   #
          S$ULOAD("S$GNINI");                    # UNLOAD PROC S$GNINI #
          CODE$USED = S$LOC - S$ACODE +2;  # (+2 FOR SAFETY)           #
          IF CODE$USED GR MAXCODEUSED THEN
              MAXCODEUSED = CODE$USED;
  
#     SHRINK CODE$ TO MAXIMUM OF ALL CODE BLOCKS                       #
  
          UNUSED = CODE$LENGTH - MAXCODEUSED; 
          CODE$LENGTH = MAXCODEUSED;
          S$CMSLF(CODE$, UNUSED); 
  
#     UNLOAD THE MODULE FOR GENERATING CODE TO GET A USER RECORD       #
  
          S$ULOAD("S$GNGRU"); 
  
  
          END  # S$GNSRT #
          TERM
