*DECK S$MAIN
          PROC S$MAIN;
  
*CALL COPYRIGHT 
#**       S$MAIN -  MAIN CONTROLLER OF SORT/MERGE                      #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$MAIN:                                                      #
#                                                                      #
#     GIVEN-                                                           #
#         NOTHING.                                                     #
#                                                                      #
#     DOES-                                                            #
#         GETS THE SPECIFICATION OF THE SORT OR MERGE FROM THE USER.   #
#         IF THERE WERE ERRORS,                                        #
#             RETURN APPROPRIATE ERROR STATUS INFORMATION.             #
#         IF A SORT WAS SPECIFIED,                                     #
#             CALLS THE SORT PROCESSOR                                 #
#         ELSE                                                         #
#             CALLS THE MERGE PROCESSOR.                               #
#         WRITES OUT STATISTICS CONCERNING THE RUN.                    #
  
  
          BEGIN 
  
*CALL A 
  
  
*CALL MACHINE 
  
          BASED 
*CALL SPEC$ 
  
*CALL STATUS$ 
  
*CALL E$
          XDEF
              BEGIN 
              ITEM S$LOC      I;
              ITEM S$POS      I;
              ITEM S$ACODE    I;
              ITEM S$LCODE    I;
              ITEM S$IRRL     I;
              ITEM S$LK       I;
              ITEM S$LR       I;
              ITEM S$OREC     I;
              ITEM S$ORSA     I;
              ITEM S$SMERR    I;       # FLAG FOR SUMMING OVERFLOW     #
              END 
          XREF
*CALL S$CALLR 
  
*CALL JCREG 
  
          XREF
              BEGIN 
              PROC  S$CMALF;           # ALLOCATE BLOCK APACE          #
              PROC  S$CMFRF;           # FREE BLOCK                    #
              PROC  S$CMSLF;           # SHRINK BLOCK                  #
              PROC  S$LOAD;            # LOAD A CAPSULE (170)          #
              PROC  S$ULOAD;           # UNLOAD A CAPSULE  (170)       #
              PROC  S$GTSPC;           # SET SPEC$                     #
              PROC  S$MRGPH;           # HANDLE THE MERGE PHASE        #
              PROC  S$REFRM;           # REFERENCE CRM AND FDL         #
              PROC S$RTNFL;            # RETURN INTERNAL FILES         #
              PROC  S$RTNZZ;           # RETURN ONE ZZ-FILE            #
              PROC  S$SRTPH;           # HANDLE THE SORT PHASE         #
              PROC S$ABT;                      # ABORTS THE SORT       #
              PROC S$ERROR; 
              PROC S$STRPV;            # SET REPRIEVE PROCESSING       #
              PROC S$COLST;            #  SET STATISTICAL ARRAY        #
              PROC  S$INFO;            # DISPLAY CONSOLE MESSAGE       #
              END 
  
          XREF
              BEGIN 
              ITEM S$MXERR;          # HIGHEXT SEVERITY OF ERROR MET   #
              ITEM S$JCRV   S:JCREG; # CONTROL REGISTER                #
              ITEM S$STVAR;          # 'SM5ST' VARIABLE USED           #
              END 
  
          ITEM ERROR     B;       # TRUE IFF CERTAIN ERROR COND. FOUND #
          ITEM LONGSUM        B;
          ITEM UNUSED     I;       # NUM. OF WORD UNUSED IN SPEC$ BLOCK#
          ITEM  ZZZZZ3X = O"32323232323630000001";
          ITEM  ZZZZZ3Y = O"32323232323631000001";
          ITEM  ZZZZZ3Z = O"32323232323632000001";
          ITEM  STARTMESS C(40) = "SORT5 - PREPARING TO SORT "; 
          ITEM  DAYFILE      B;  # REMEMBER DAYFILE SUPPRESSION        #
  
  
          XDEF     ITEM    S$FSTPS    I;
  
          BASED ARRAY FIT[1:FITSIZE]; 
              ITEM  FIT$WORD U(0,0,60); 
          BASED ARRAY DUMFIT[1:FITSIZE];
                 ITEM DUM$WORD U(0,0,60); 
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
  
  
          PROC TESTERR(ERROR);
#                                                                      #
#         TESTERR - TEST THE ERROR LEVEL, THEN TAKE ACTION             #
#                                                                      #
#         GIVEN -                                                      #
#               ERROR = BOOL. SET WITHIN TESTERR, INITIALLY SET FALSE  #
#                                                                      #
#         DOES - DEPENDING ON WHAT VALUES THE VARIABLES 'S$MXERR',     #
#               'S$JCRV', AND 'S$STVAR' HAVE BEEN SET WITH, PARTICULAR #
#               ERROR PROCESSING ACTION CAN TAKE PLACE                 #
#                                                                      #
          BEGIN 
  
          ITEM ERROR     B;       # TRUE IFF CERTAIN ERROR COND. FOUND #
  
          ERROR = FALSE;          # INITIALIZED TO FALSE               #
          IF (NOT STATUS$NORML)  OR (S$MXERR NQ 0)  THEN
              BEGIN 
              IF S$MXERR EQ 0  THEN    # S$MXERR HAS BEEN UNCHANGED    #
                  BEGIN                # NO ERROR ENCOUNTERED          #
                  ERROR = TRUE;        # 'QUIT' CALLED - DO NOT ABORT  #
#***#             RETURN;              # END SORT                      #
                  END 
  
              IF S$MXERR GQ 40  THEN   # FATAL OR CAT. ERRORS FOUND    #
                  BEGIN 
                  IF S$JCRV EQ 0  AND S$STVAR EQ 0  THEN
                                       # 'STATUS' VALUE NOT GIVEN      #
                      BEGIN 
                      S$ERROR(0, " ", 0); 
                      ERROR = TRUE; 
                      S$ABT;
                      END 
  
                  IF S$JCRV NQ 0  OR  S$STVAR NQ 0  THEN
                                       # 'STATUS' VALUE SPECIFIED      #
                      BEGIN 
                      S$ERROR(0, " ", 0);       # FLUSH ERROR MESSAGES #
                      ERROR = TRUE; 
#***#                 RETURN; 
                      END 
                  END 
  
#               OTHERWISE NO FATAL OR CATASTROPHIC ERRORS ENCOUNTERED  #
  
              END 
  
          END  # OF TESTERR # 
CONTROL EJECT;
  
          # BEFORE WE GENERATE CODE OR SORT, SET THE ADDRESSES         #
          # FOR REPRIEVE PROCESSING TO RETURN INTERNAL FILES           #
          # JUST IN CASE THERE IS AN ABORT                             #
          # THIS REPRIEVE PROCESSING IS ONLY SET IF S$CALLR = 1        #
          # OR S$CALLR = 4 (CALLED FROM CONTROL CARD OR INTERACTIVE    #
          # DIALOGUE                                                   #
          # ALSO RETURN INTERNAL FILES ON THE WAY IN                   #
          # ALSO SHOW CONSOLE MESSAGE FOR S$MAIN                       #
  
          S$INFO(STARTMESS);
  
          S$RTNZZ(ZZZZZ3X);            # RETURN CODE FILE              #
          S$RTNZZ(ZZZZZ3Y);            # RETURN CODE FILE              #
          DAYFILE = TRUE;  # SET THE DEFAULT #
          S$SMERR = 0;                 # DEFAULT FOR SUMMING ERROR     #
  
          IF S$CALLR EQ 1 OR S$CALLR EQ 4 THEN
              S$STRPV;
  
# ALLOCATE MEMORY SPACE FOR 8 FITS AND OPEN THEN CLOSE DUMMY FILE      #
# TO REFERENCE CRM AND FDL IN LOW CORE #
  
          S$CMALF(P<FIT>, 8*FITSIZE, 0, 0); 
          S$REFRM(P<FIT>);
  
          S$RTNZZ(ZZZZZ3Z);            # RETURN DUMMY FILE             #
#     GET THE SPECIFICATION FROM THE USER                              #
  
          S$CMALF(P<SPEC$>, SPEC$LEN, 2, 0);
  
          SPEC$LOFIT = P<FIT>;
  
          S$LOAD("S$GTSPC");           # LOAD PROCEDURE S$GTSPC        #
          S$GTSPC(SPEC$,UNUSED,STATUS$,LONGSUM); #SET SPEC$, UNUSED ETC#
          S$ULOAD("S$GTSPC");          # UNLOAD PROCEDURE S$GTSPC      #
          S$ERROR(0);  # REPORT ERRORS SO FAR # 
  
  
          TESTERR(ERROR);              # TEST ERROR LEVEL              #
          IF ERROR  THEN               # FATAL ERROR OR "QUIT" OCCURRED#
#***#         RETURN;                  # END PROCESSING                #
  
          S$CMSLF(SPEC$,UNUSED);       # SHRINK BLOCK OF USED SPACE    #
  
          IF SPEC$NODAY THEN
              DAYFILE = FALSE;
# IF INVOKED FROM SMABT, DO NOT PROCEED FROM HERE                      #
  
          IF S$CALLR EQ 5 THEN
#***#         RETURN; 
  
  
          # CALL S$REFRM A SECOND TIME TO FORCE OPEN$RM # 
          # OUT OF MEMORY.                              # 
  
          S$CMALF(P<DUMFIT>, 8*FITSIZE, 0, 0);
          S$REFRM(P<DUMFIT>); 
          S$RTNZZ(ZZZZZ3Z); 
          S$CMFRF(DUMFIT);
#     HANDLE A SORT OR MERGE                                           #
          IF LONGSUM THEN 
              S$LOAD("S$LNGSM");
  
          IF SPEC$SORT  THEN           # IF A SORT WAS SPECIFIED       #
              BEGIN 
              S$LOAD("S$SRTPH");       # LOAD THE CAPSULE              #
              S$SRTPH(SPEC$);          # HANDLE THE SORT PHASE         #
              S$ULOAD("S$SRTPH");      # UNLOAD THE CAPSULE            #
              END 
          ELSE               # IF A MERGE WAS SPECIFIED                #
              BEGIN 
              S$LOAD("S$MRGPH");       # LOAD THE CAPSULE              #
              S$MRGPH(SPEC$);          # HANDLE THE MERGE PHASE        #
              S$ULOAD("S$MRGPH");      # UNLOAD THE CAPSULE            #
              END 
  
          S$CMFRF(SPEC$);              # RELEASE THE WHOLE BLOCK       #
          S$CMFRF(FIT);                # THROW AWAY DUMMY FIT          #
  
          IF LONGSUM THEN 
              S$ULOAD("S$LNGSM"); 
          S$COLST(DAYFILE); 
  
          S$RTNZZ(ZZZZZ3X);            # RETURN CODE FILE              #
          S$RTNZZ(ZZZZZ3Y);            # RETURN CODE FILE              #
          IF S$SMERR NQ 0 THEN
              S$ERROR(E$120);          # TELL USER ABOUT SUM OVERFLOW  #
  
          TESTERR(ERROR);              # TEST ERROR LEVEL              #
          IF ERROR  THEN
#***#         RETURN;                  # S$ERROR(0) WAS ALREADY CALLED #
  
          S$ERROR(0, " ", 0); 
  
          END  # S$MAIN # 
          TERM
