*DECK S$GNINI 
          PROC S$GNINI(SPEC$, WSAS$, REC$); 
  
#**       S$GNINI -  GENERATE INIT-CODE                                #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GNINI(SPEC$, WSAS$, REC$):                                 #
#                                                                      #
#     GIVEN-                                                           #
#         SPEC$ = USER SPECIFICATION.                                  #
#         REC$ = ARRAY TO HOLD INTERNAL RECORD FORMAT.                 #
#         WSAS$ = ARRAY TO HOLD ALLOCATION OF WORKING STORAGE AREA.    #
#         S$ACODE = ADDRESS TO START GENERATING CODE.                  #
#         S$LCODE = NUMBER OF WORDS AT S$ACODE.                        #
#         S$LOC = ADDRESS FOR NEXT INSTRUCTION.                        #
#         S$POS = BIT POSITION WITHIN (S$LOC) FOR NEXT INSTRUCTION.    #
#                                                                      #
#     DOES-                                                            #
#         SETS CODE$ (VIA S$LOC) TO GENERATED CODE TERMED "INIT-CODE". #
  
  
          BEGIN 
  
*CALL A 
  
*CALL REC$
  
*CALL SPEC$ 
  
*CALL WSAS$ 
  
          XREF
              BEGIN 
              PROC  S$ABORT;          # ABORT ROUTINE                  #
              PROC  S$GNCMP;           # GEN- COMPARE RECORDS          #
              PROC  S$GNGRU;           # GEN- GET RECORD FROM USER     #
              PROC  S$GNIN1;           # GENERATE INIT-CODE, PART 1    #
              PROC  S$GNIN2;           # GENERATE INIT-CODE, PART2     #
              PROC  S$GNIN3;           # GENERATE INIT-CODE, PART3     #
              PROC  S$GNSUM;          # GENERATE SUMMING CODE          #
              END 
  
          XREF
              BEGIN                    # USED BY S$GNINV               #
              ITEM  S$IRRL   I;        # REC$IRRL                      #
              ITEM  S$LK     I;        # NUMBER OF USED KEY BITS       #
              ITEM  S$LR     I;        # NUMBER OF BITS FOR REC. NUM.  #
              ITEM  S$OREC   I;        # WSA$ OFFSET TO EXTERNAL REC   #
              ITEM  S$ORSA   I;        # WSA$ OFFSET TO REC STOR AREA  #
              PROC  S$GNVFY ;          # GENERATE MERGE-VERIFY         #
              END 
  
  
          ITEM  BUFREC       B;        # TRUE IF REMAINDER OF REC. IN  #
                                       #   BUFFER RATHER THAN IN RSA   #
          CONTROL INERT;
  
          CONTROL DISJOINT; 
  
CONTROL EJECT;
  
#     SET GLOBALS USED BY LOW-LEVEL CODE GENERATORS                    #
  
          S$IRRL = REC$IRRL;
          S$LK = 0; 
          S$LR = REC$LR;
          S$OREC = WSAS$OREC; 
          S$ORSA = WSAS$ORSA; 
  
#     GENERATE INIT-CODE, PART 1                                       #
  
          IF SPEC$1STINF NQ 0 THEN
              S$GNIN1(WSAS$LTRN, SPEC$INFIT[SPEC$1STINF], WSAS$OREC,
                  REC$LR, SPEC$FASTIN, SPEC$RETAIN);
          ELSE
              S$GNIN1(WSAS$LTRN, 0, WSAS$OREC,
                REC$LR, SPEC$FASTIN, SPEC$RETAIN);
  
#     GENERATE GET-INTERNAL-RECORD-FROM-USER                           #
  
          S$GNGRU(SPEC$, WSAS$, REC$);
  
#     GENERATE INIT-CODE, PART 2                                       #
  
          S$GNIN2(WSAS$LTRN, REC$LR); 
  
#     GENERATE COMPARE CODE                                            #
  
          BUFREC = FALSE; 
  
          $BEGIN
          IF REC$LO1+REC$LO2 NQ 0 AND SPEC$1STSUM NQ 0 THEN 
              S$ABORT("S$GNINI"); 
          $END
  
          S$GNCMP(WSAS$ORSA,REC$IRRL,REC$LR,REC$LK1,REC$LK2,
                  REC$LO1,REC$LO2,BUFREC,SPEC$1STSUM);
  
          IF SPEC$1STSUM NQ 0 THEN
              S$GNSUM(SPEC$,WSAS$ORSA,REC$IRRL,REC$LR,BUFREC);
  
#     GENERATE INIT-CODE, PART 3                                       #
  
          S$GNIN3(SPEC$RETAIN); 
  
          IF SPEC$VERIFY THEN 
              S$GNVFY(REC$LK1,REC$LK2); 
          END  # S$GNINI #
          TERM
