*DECK S$ALCS
          PROC  S$ALCS(SPEC$, REC$, WSAS$); 
  
#**       S$ALCS -  ALLOCATE WSA FOR INIT-CODE, SHORT-CODE, LONG-CODE  #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$ALCS(SPEC$, REC$, WSAS$):                                  #
#                                                                      #
#     GIVEN-                                                           #
#         SPEC$ = USER SPECIFICATION.                                  #
#         REC$ = FORMAT OF INTERNAL RECORD.                            #
#         WSAS$ = ARRAY TO HOLD ALLOCATION.                            #
#                                                                      #
#     DOES-                                                            #
#         SETS WSAS$ TO ALLOCATION OF THE WORKING STORAGE AREA FOR     #
#          INIT-CODE, SHORT-CODE AND LONG-CODE.                        #
  
  
          BEGIN 
  
*CALL A 
  
*CALL MACHINE 
  
*CALL REC$
  
*CALL SPEC$ 
  
*CALL WSAS$ 
  
          XREF
              PROC  S$ABORT;           # DIAGNOSE AN INTERNAL ERROR    #
  
          ITEM  LOREC        I;        # LENGTH OF OREC                #
          ITEM  LRSA         I;        # LENGTH OF RECORD STORAGE AREA #
          ITEM  OFFSET       I;        # WORD OFFSET FROM START OF WSA #
          ITEM  UNUSED       I;        # NUMBER OF UNUSED WORDS        #
          ITEM  USED         I;        # NUMBER OF USED WORDS          #
  
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
CONTROL EJECT;
  
#     DETERMINE THE LENGTH OF EACH AREA                                #
  
          IF SPEC$FIXED THEN
              LOREC = (SPEC$FIXLEN + WORD - 1)/WORD + 1;
              # COBOL5 RELATIVE I/O MAY CLOBBER AN EXTRA WORD # 
          ELSE
              LOREC = (SPEC$MRL + WORD - 1)/WORD + 1; 
              #( S$GNCVE MAY CLOBBER LAST WORD + 1)#
  
          WSAS$LSTRTBL = PRU + 1 + FET; 
  
          # SET THE LENGTH OF THE CIO BUFFER                           #
  
          #     (CODE FROM ST5A334 SET THE SIZE AS ONE-FIFTH SPEC$LWSA.#
          #      FOR THE TYPICAL CASE OF SPEC$LWSA = 16000 THIS GAVE   #
          #      WSAS$LCIOB = 6201B, WHICH WAS REDUCED DOWN TO 2701B   #
          #      IF INTERMEDIATE MERGES COULD BE AVOIDED.              #
          #      THESE LARGE BUFFER SIZES ARE LIKELY TO BE TOO LARGE   #
          #      FOR SHORT SORTS BECAUSE IT IS MORE IMPORTANT TO TRY   #
          #      TO AVOID AN INTERMEDIATE OR FINAL MERGE.              #
          #      THESE LARGE BUFFER SIZES ARE LIKELY TO BE TOO LARGE   #
          #      FOR LONG SORTS BECAUSE IT IS SO CRITICAL TO INCREASE  #
          #      THE NUMBER OF RECORDS PER STRING FILE.                #
          #      OF COURSE, PERFORMANCE TESTING MAY OVERRULE THIS      #
          #      THEORY, PERHAPS FOR VERY LARGE RECORDS.)              #
          #     (NOTE THAT BUFFER SIZE OF PRU-MULTIPLE + 1 IS WASTEFUL #
          #      EXCEPT FOR THE FIRST READ, BECAUSE SUBSEQUENT INPUT   #
          #      IS INITIATED WHEN NO FULL RECORD IS IN MEMORY.        #
          #      AT THAT POINT THE BUFFER SHOULD HAVE PRU-MULTIPLE + 1 #
          #      UNUSED WORDS IN IT.)                                  #
          WSAS$LCIOB = LCIOB + REC$IRRL;
  
              USED = 0   # I-O BUFFERS ALLOCATED DYNAMICALLY #
               + LOREC                           # EXTERNAL RECORD     #
               + WSAS$LSTRTBL                    # STRING TABLE        #
               + WSAS$LCIOB;                     # CIO BUFFER          #
  
          UNUSED = SPEC$LWSA - USED;   # NUMBER OF UNUSED WORDS        #
  
          IF (UNUSED - 2 * (REC$IRRL + 1)) LS 0 THEN
              BEGIN # CANNOT EVEN HAVE 2 RECORDS IN TOURNAMENT #
              END 
  
          WSAS$LTRN = UNUSED/(REC$IRRL+1);
  
          LRSA = WSAS$LTRN*REC$IRRL;
  
#     DISTRIBUTE ANY UNUSED WORDS APPROPRIATELY                        #
  
          UNUSED = UNUSED - WSAS$LTRN - LRSA; 
  
  
          WSAS$LSTRTBL = WSAS$LSTRTBL + UNUSED; 
  
#     NOW SET THE OFFSETS                                              #
  
          OFFSET = WSAS$LTRN;          # TOURNAMENT STARTS AT ZERO     #
  
          WSAS$OREC = OFFSET;                    # EXTERNAL RECORD     #
          OFFSET = OFFSET + LOREC;
  
          WSAS$ORSA = OFFSET;                    # RECORD STORAGE AREA #
          OFFSET = OFFSET + LRSA; 
  
          WSAS$OSTRTBL = OFFSET;                 # STRING TABLE        #
          OFFSET = OFFSET + WSAS$LSTRTBL; 
  
          WSAS$OCIOB = OFFSET;                   # CIO BUFFER          #
          OFFSET = OFFSET + WSAS$LCIOB; 
  
          IF OFFSET NQ SPEC$LWSA THEN 
              S$ABORT("S$ALCS-2");
  
          WSAS$LTRN = WSAS$LTRN -1;              # 1 FOR WINNER KEY    #
  
          END  # S$ALCS # 
          TERM
