*DECK S$SEQ 
          PROC  S$SEQ(NPARMS, COLSEQ, ARRY);
  
#**       S$SEQ -  GATHER PARAMETERS ABOUT A COLLATING SEQUENCE        #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         CALL SMSEQ(<COLSEQ>, <ARRY>)                                 #
#         (THIS CALLS THE MACHINE-DEPENDENT ROUTINE SMSEQ WHICH        #
#          COUNTS PARAMETERS AND CALLS S$SEQ.)                         #
#                                                                      #
#     GIVEN-                                                           #
#         <NPARMS> = NUMBER OF PARAMETERS SUPPLIED.                    #
#         <COLSEQ> = NAME OF THE COLLATING SEQUENCE BEING DEFINED.     #
#          (LEFT-JUSTIFIED, BLANK-FILLED)                              #
#         <ARRY> = NAME OF ARRAY CONTAINING CHARACTERS IN THE ORDER    #
#          THEY ARE TO BE COLLATED.  EACH CHARACTER SHOULD BE          #
#          RIGHT-JUSTIFIED WITH BINARY-ZERO-FILL, OR IN BINARY.        #
#          UNSPECIFIED CHARACTERS COLLATE HIGH AND EQUAL.  THE         #
#          COLLATING SEQUENCE IS TERMINATED BY A NEGATIVE NUMBER.      #
#                                                                      #
#     DOES-                                                            #
#         IF CALLED IN THE WRONG ORDER,                                #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         IF EXACTLY 1 OR 2 PARAMETERS WERE NOT ORIGINALLY SUPPLIED,   #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         IF <COLSEQ> WAS ZERO,                                        #
#             ASSUME "6BIT".                                           #
#         SAVE RAW PARAMETER OF-                                       #
#             TYPE = RP$T"SEQNAM",                                     #
#             GROUP = <NEW-GROUP>,                                     #
#             VALUE = <COLLATING SEQUENCE NAME>.                       #
#         FOR EACH VALUE IN <ARRY> UNTIL VALUE IS NEGATIVE,            #
#             SAVE RAW PARAMETER OF-                                   #
#                 TYPE = RP$T"SEQVAL",                                 #
#                 GROUP = <COLSEQ-GROUP >,                             #
#                 ORDINAL = <INCREMENTED VALUE>,                       #
#                 VALUE = VALUE IN <ARRY>.                             #
  
  
          BEGIN 
*CALL NPARMS
          ITEM  COLSEQ       C(7);     # NAME FOR COLLATING SEQUENCE   #
          ARRAY  ARRY [1:257];         # ARRAY WITH CHARACTERS         #
              ITEM  ARRY$VAL     I(0, 0,60);     # CHARACTER OR -1     #
  
          XREF
              BEGIN 
              PROC  S$ERROR;           # HANDLE A USER ERROR           #
              FUNC  S$INSEQ  B;        # TRUE IFF CALL IN SEQUENCE     #
              FUNC  S$NEWGR  I;        # NEW GROUP NUMBER              #
              PROC  S$SVREL;           # SAVE RAW PARAM. FROM RELOC.   #
              FUNC  S$ZERO   B;        # TRUE IFF BINARY ZERO          #
              END 
  
*CALL A 
  
*CALL E$
  
*CALL RP$ 
  
*CALL SQ$ 
  
          ITEM  CSNAME       C(7);     # COLLATING SEQUENCE NAME       #
          ITEM  GROUP        I;        # NUMBER OF CURRENT GROUP       #
          ITEM  ORD          I;        # ORDINAL OF VALUE              #
  
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
  
#     IF CALLED IN THE WRONG ORDER,                                    #
#         ISSUE A DIAGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NOT S$INSEQ(SQ$"SMSEQ")  THEN
              BEGIN 
              S$ERROR(E$110);          # CALL OUT OF SEQUENCE          #
#***#         RETURN; 
              END 
  
#     IF EXACTLY 1 OR 2 PARAMETERS WERE NOT ORIGINALLY SUPPLIED,       #
#         ISSUE A DIAGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NPARMS LQ 0
           OR NPARMS GR 2  THEN 
              BEGIN 
              S$ERROR(E$108);          # TOO FEW/MANY PARAMETERS       #
#***#         RETURN; 
              END 
  
#     IF <COLSEQ> WAS ZERO,                                            #
#         ASSUME "6BIT".                                               #
  
          IF S$ZERO(COLSEQ)  THEN      # IF BINARY ZERO                #
              CSNAME = "6BIT";
          ELSE
              CSNAME = COLSEQ;
  
#      SAVE RAW PARAMETER OF-                                          #
#         TYPE = RP$T"SEQNAM"                                          #
#         GROUP = <NEW-GROUP>,                                         #
#         VALUE = <COLLATING SEQUENCE NAME>.                           #
  
          RP$TYPE = RP$T"SEQNAM"; 
          GROUP = S$NEWGR;             # GET NEW GROUP NUMBER          #
          RP$GROUP = GROUP; 
          RP$VALUEC = CSNAME; 
          S$SVREL(RP$); 
  
#     FOR EACH VALUE IN <ARRY> UNTIL VALUE IS NEGATIVE,                #
#         SAVE RAW PARAMETER OF-                                       #
#             TYPE = RP$T"SEQVAL",                                     #
#             GROUP = <COLSEQ-GROUP>,                                  #
#             ORDINAL = <INCREMENTED VALUE>,                           #
#             VALUE = VALUE IN <ARRY>.                                 #
  
          FOR ORD = 1 STEP 1 WHILE ARRY$VAL[ORD] GQ 0  DO 
              BEGIN 
              RP$TYPE = RP$T"SEQVAL"; 
              RP$GROUP = GROUP; 
              RP$ORDINAL = ORD; 
              RP$VALUE = ARRY$VAL[ORD]; 
              S$SVREL(RP$); 
              END 
  
          END  # S$SEQ #
          TERM
