*DECK S$5SEQS 
          PROC S$5SEQS(NPARMS, CSARRY); 
#**       S$5SEQS - SPECIFY USER-SUPPLIED COLLATING SEQUENCE           #
#                                                                      #
#      CALLING SEQUENCE -                                              #
#         CALL S$5SEQS(NPARMS, CSARRY)                                 #
#                                                                      #
#      GIVEN -                                                         #
#         NPARMS = NUMBER OF PARAMETERS THAT 'SM5SEQS' WAS CALLED WITH #
#         CSARRY = ARRAY CONTAINING THE ACTUAL PARAMETERS FOR 'SM5SEQS'#
#                                                                      #
#      DOES -                                                          #
#         CHECKS THAT THE PARAMETERS GIVEN FOR SM5SEQS (THOSE IN       #
#            CSARRY) ARE SINGLE CHARACTERS.                            #
#         ALSO CHECK THAT THERE ARE NO MORE THAN 64 PARAMETERS GIVEN   #
#         CALLS S$SEQX TO CHECK THE CALLING ORDER OF THIS SM5SEQS CALL #
#            IN RELATION TO THE OTHER SEQ_ CALLS                       #
#         IF ONLY ONE PARAMETER WAS GIVEN THEN SET RP$SEQVAL.          #
#         IF MORE THAN ONE PARAMETER WAS GIVEN THEN:  SET RP$EQUNAM,   #
#            RP$EQUVAL, AND RP$SEQVAL FOR EACH OF THE PARAMETERS.      #
#            WHEN SETTING RP$EQUVAL AND RP$EQUNAM USE THE NEW GROUP    #
#            NUMBER SUPPLIED BY S$SEQX WHEN S$SEQX IS CALLED WITH      #
#            CALLTYP = 0.                                              #
#                                                                      #
  
BEGIN 
  
*CALL A 
  
*CALL E$
  
*CALL RP$ 
  
*CALL STATUS$ 
  
*CALL CSTYP 
  
*CALL SQ$ 
  
#           ITEMS USED IN THE ROUTINE                                  #
  
          ITEM BADP       B;        # TRUE IF 'P' IS BAD               #
          ITEM CALLTYP    S:CSTYP;  # ROUTINE CALLING S$SEQX           #
          ITEM CH         C(1);     # SINGLE CHARACTER                 #
          ITEM EQUGR;               # NEW GROUP NUMBER FOR EQUVAL      #
          ITEM GROUP;               # CURRENT GROUP NUMBER FOR SEQ     #
          ITEM J;                   # FOR-LOOP INCREMENT               #
          ITEM NPARMS;              # NO. OF PARMS. SM5SEQS CALLED WITH#
          ITEM P          C(10);    # PARAMETER VALUE                  #
          ITEM SEQNM      C(10);    # CURRENT COL-SEQ. NAME            #
          ITEM VAL;                 # OCTAL REPRESENTATION OF 'P'      #
  
          ARRAY CSARRY [1: 100] S(1); 
              ITEM CSARRY$VAL         C(0, 0, 10);
  
          XREF
              BEGIN 
              PROC S$ERROR; 
              PROC S$SEQX;
              PROC S$SVREL;         # STORES THE RAW PARAMETERS        #
              FUNC S$INSEQ  B;      # TRUE IFF SEQ. ORDER IS CORRECT   #
              END 
  
  
          PROC TESTPRM(PARM, BADPARM);
#         TESTPRM - TEST THAT THE PARAMETER IS A SINGLE CHARATER       #
#                                                                      #
#         GIVEN -                                                      #
#      GIVEN -                                                         #
#         PARM = STRING CONTAINING ONE OF THE PARAMETERS OF 'SM5SEQS'  #
#         BADPARM = FLAG RETURNED TO CALLER, TRUE IF PARAMETER IS BAD  #
#                                                                      #
#      DOES -                                                          #
#         CHECKS THAT THE PARM GIVEN CONTAINS BLANKS (IS BLANK-FILLED) #
#            FROM THE SECOND CHARACTER TO THE END OF THE STRING        #
#         IF THE PARM CONTAINS MORE THAN ONE CHARACTER, ISSUE ERROR    #
#            THEN SET BADPARM = TRUE, AND RETURN.                      #
#                                                                      #
  
          BEGIN 
  
          ITEM C;                   # INCREMENT VALUE                  #
          ITEM BADPARM  B;          # FLAG SET TRUE IF PARAMETER BAD   #
          ITEM PARM     C(10);      # GIVEN PARAMETER VALUE            #
  
          BADPARM = FALSE;            # RESET BADPARM BEFORE CHECKING  #
  
          FOR C = 1  STEP 1  UNTIL 9  DO
              BEGIN 
              IF NOT (C<C,1>PARM EQ " ")  THEN
                  BEGIN 
                  S$ERROR(E$112);   # ONLY SINGLE CHARACTER LITERALS   #
#                    CAN BE USED AS PARAMETERS OF SM5SEQS              #
                  STATUS$NORML = FALSE; 
                  BADPARM = TRUE; 
#***#             RETURN; 
                  END 
  
              END 
          END   # OF TESTPRM #
  
CONTROL EJECT;
  
          IF NOT S$INSEQ(SQ$"SM5SEQ")   THEN
              BEGIN 
              S$ERROR(E$110);       # CALL OUT OF SEQUENCE             #
#***#         RETURN; 
              END 
  
          CALLTYP = CSTYP"SEQS";
          S$SEQX(CALLTYP, GROUP, 0, SEQNM); 
  
          IF NPARMS EQ 1  THEN
              BEGIN 
              P = CSARRY$VAL[1];
              TESTPRM(P,BADP);
              IF BADP  THEN 
                  BEGIN 
#***#             RETURN; 
                  END 
  
#               OTHERWISE SET RP$ VALUES                               #
  
              CH = C<0,1>P; 
              VAL = B<0,6>CH; 
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SEQVAL"; 
              RP$VALUE = VAL; 
              S$SVREL(RP$); 
              END 
  
          IF NPARMS GR 1  THEN   # EQUATES USED                        #
              BEGIN 
              S$SEQX(0, GROUP, EQUGR, SEQNM); 
              FOR J = 1  STEP 1  UNTIL 64  DO 
                  BEGIN 
                  IF J GR NPARMS  THEN
#***#                 RETURN; 
  
                  P = CSARRY$VAL[J];
                  TESTPRM(P, BADP); 
                  IF BADP  THEN 
#***#                 RETURN; 
  
#                   OTHERWISE SET RP$ VALUES                           #
  
                  CH = C<0,1>P; 
                  VAL = B<0,6>CH; 
  
                  RP$GROUP = EQUGR; 
                  RP$TYPE = RP$T"EQUNAM"; 
                  RP$VALUEC = SEQNM;
                  S$SVREL(RP$); 
  
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"SEQVAL"; 
                  RP$VALUE = VAL; 
                  S$SVREL(RP$); 
  
                  RP$GROUP = EQUGR; 
                  RP$TYPE = RP$T"EQUVAL"; 
                  RP$VALUE = VAL; 
                  S$SVREL(RP$); 
  
                  END 
              END  # OF FOR-LOOP #
  
          END  # OF S$5SEQS # 
          TERM
