*DECK S$GNOPM 
          PROC  S$GNOPM(SMT$, REC$, SPEC$, WSAO$, CODE$); 
  
#**       S$GNOPM -  GENERATE ONE-PASS MERGE CODE                      #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GNOPM(SMT$, REC$, SPEC$, WSAO$, CODE$):                    #
#                                                                      #
#     GIVEN-                                                           #
#         SMT$   = LIST OF FILES TO BE MERGED                          #
#         REC$   = FORMAT OF INTERNAL RECORD.                          #
#         SPEC$  = USER SPECIFICATION.                                 #
#         WSAO$  = ALLOCATION OF WSA$ FOR ONE-PASS MERGE               #
#         CODE$  = LOCATION FOR GENERATED CODE.                        #
#                                                                      #
#     DOES-                                                            #
#         GENERATES ONE-PASS MERGE CODE INTO CODE$                     #
  
  
          BEGIN 
  
*CALL A 
*CALL SMT$
*CALL SPEC$ 
*CALL CODE$ 
*CALL REC$
*CALL WSAO$ 
  
          XREF
              BEGIN 
              PROC  S$ABORT;           # HANDLE INTERNAL ABORT         #
              PROC  S$ALOPM;           # ALLOCATE WSA FOR OP MERGE     #
              PROC  S$CMSLF;           # SHRINK MEMORY BLOCK AT LWA    #
              PROC  S$DSASM;           # DISASSEMBLE CODE$ TO LISTING  #
              PROC  S$GNCMP;           # GEN- COMPARE CODE             #
              PROC  S$GNFET;           # GEN- FETS FOR FNLMRG FILES    #
              PROC  S$GNGOM;           # GEN- GET ONE-PASS MERGE REC   #
              PROC  S$GNINV;           # GEN- INVERT RECORD CODE       #
              PROC  S$GNJSR;           # GEN- ENTRY/EXIT FOR INV CODE  #
              PROC  S$GNOM1;           # GEN- ONE-PASS MERGE CODE, 1   #
              PROC  S$GNOM2;           # GEN- ONE-PASS MERGE CODE, 2   #
              PROC  S$GNOM3;           # GEN- ONE-PASS MERGE CODE, 3   #
              PROC  S$GNOM4;           # GEN- ONE-PASS MERGE CODE, 4   #
              PROC  S$GNPRU;           # GEN- PUT RECORD TO USER       #
              PROC  S$GNRTN;           # GEN- RETURN FROM INVERT CODE  #
              PROC  S$GNSUM;           # GEN- SUMMING CODE             #
              PROC  S$GNVFY;           # GEN- VERIFY CODE              #
              PROC  S$INITL;           # INITIALIZE  LABELS            #
              PROC  S$LOAD;            # LOAD A MODULE                 #
              PROC  S$PRTCD;           # PRINT OUT CODE                #
              PROC  S$ULOAD;           # UNLOAD A MODULE               #
              END 
  
          XREF
              BEGIN                    # USED BY S$GNREV               #
              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  #
              END 
  
           XREF 
              BEGIN 
              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  LF           I;        # FOR S$GNGIV                   #
          ITEM  LL           I;        # FOR S$GNGIV                   #
          ITEM  OFFSET       I;        # FOR S$GNGIV                   #
          ITEM  UNUSED       I;        # PARAMETER TO S$CMSLF          #
  
          ITEM  BUFREC       B;        # TRUE IF REMAINDER OF REC. IN  #
                                       #   BUFFER RATHER THAN IN RSA   #
          ITEM LINE          C(60); 
          ITEM  I            I; 
  
          CONTROL DISJOINT ;
  
          CONTROL INERT ; 
  
CONTROL EJECT ; 
  
           # SET WSA FOR ONE-PASS MERGE                                #
  
          S$ALOPM(SMT$,WSAO$, SPEC$, REC$); # SET WSAO$                #
  
          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  #
  
#     SET GLOBALS USED BY LOW-LEVEL CODE GENERATORS                    #
  
          S$IRRL = REC$IRRL;
          S$LK = 0; 
          S$LR = REC$LR;
          S$OREC = WSAO$OREC; 
          S$ORSA = WSAO$ORSA; 
  
          S$GNOM1(WSAO$LTRN, REC$LR, SPEC$OUTFIT, 
                  WSAO$OREC, SMT$, SPEC$VERIFY);
  
          S$LOAD("S$GNPRU");
          S$GNPRU(SPEC$, WSAO$OREC, WSAO$ORSA, REC$); 
          S$ULOAD("S$GNPRU"); 
  
#         RESET S$LK AFTER S$GNPRU                                     #
          S$LK = 0; 
          S$GNOM2(WSAO$LTRN, WSAO$ORSA, REC$LR, REC$IRRL);
  
          S$GNGOM(WSAO$OREC); # GEN - GET EXT. RECORD     # 
  
          S$GNOM3;
  
          S$GNJSR;       # GENERATE ENTRY/EXIT WORD FOR INVERSION CODE #
          S$GNINV(SPEC$, REC$); # GENERATE INVERSION CODE              #
          S$GNRTN;       # RETURN TO CALLER FROM INVERSION CODE        #
  
          BUFREC = FALSE; 
  
          $BEGIN
          IF REC$LO1+REC$LO2 NQ 0 AND SPEC$1STSUM NQ 0 THEN 
              S$ABORT("S$GNOPM"); 
          $END
  
          S$GNCMP(WSAO$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$, WSAO$ORSA, REC$IRRL, REC$LR, BUFREC);
  
  
          S$GNOM4;
  
          IF SPEC$VERIFY THEN 
              BEGIN 
              S$LOAD("S$VDATA");
              S$GNVFY(REC$LK1,REC$LK2,SPEC$OUTFIT); 
              END 
  
  
          CODE$USED = S$LOC - S$ACODE + 1;       # (+1 FOR PART WORD)  #
  
          UNUSED = CODE$LENGTH - CODE$USED; 
          S$CMSLF(CODE$, UNUSED); 
  
          END  # S$GNOPM #
          TERM
