*DECK S$SSC 
          PROC S$SSC(STRING$,COL$,PDT$,TOKEN$,KN,STATUS$);
  
#**       SSC - SCAN_SET_CONTENTS                                      #
#                                                                      #
#       CALLING SEQUENCE - AS ABOVE:                                   #
#       GIVEN -                                                        #
#         COL$ = CURRENT COLUMN POSITION WITHIN STRING$(INPUT,OUTPUT)  #
#         KN = KEYWORD NUMBER WITH THE PDT(INPUT)                      #
#         PDT$ = PARAMETER_DESCRIPTION_TABLE(INPUT)                    #
#         STATUS$ = ERROR STATUS                                       #
#         STRING$ = ARRAY WHICH CONTAINS A STRING AND IT'S LENGTH      #
#                                                                      #
#       DOES -                                                         #
#          IF A PARAMETER_LIST CONTAINS A SET(S) OF VALUES THEN        #
#          THIS PROC, CALLED BY S_V_L, SETERMINES THE COLUMN POSITION  #
#          POSITION OF THE END OF THIS SET, AND CHECKS THE MINIMUM_    #
#          AND MAXIMUM_NUMBERS_OF_SETS VALUE(PDT$MINS AND PDT$MAXS)    #
#          FOR VIOLATIONS                                              #
#                                                                      #
  
          BEGIN 
  
          XREF
              BEGIN 
              ITEM   PARORD    I;        # PARENTHESIS ORDER           #
              ITEM   PAREN     B;        # HAS A PARENTHESIS BEEN FOUND#
              ITEM   SCOUNT    U;    # NUM OF VAL_SETS SCANNED THUS FAR#
              ITEM     PN    I;    # PARAMETER NUM.                    #
              END 
          ITEM   VCOUNT    I=0;     #  NUM OF VALUES WITHIN THIS SET   #
          ITEM    KN    I;         # KEYW. NUM. WITHIN PDT$            #
          ITEM MES    C(80);   # USED BY S$PRTCD                       #
  
*CALL A 
  
*CALL E$
  
*CALL CLPTYPE 
  
          XREF
              BEGIN 
*CALL PVT$
              END 
  
*CALL PDT$
  
*CALL STRING$ 
  
*CALL CLPARRA 
  
*CALL STATUS$ 
  
          XREF
              BEGIN 
              PROC S$ABORT; 
              PROC S$CKPRV; 
              PROC S$ERROR; 
              PROC S$NXTOK; 
              PROC S$PRTCD;   # PRINT A LINE TO THE FILE CODE          #
              END 
  
          FUNC  DEC(VALUE) C(10); 
              ITEM  VALUE       I;     # VALUE TO BE CONVERTED         #
              ITEM  C10PLUS     C(20);
              ITEM  I            I; 
              ITEM  N            I; 
              BEGIN 
              C10PLUS = "         0          "; 
              N = VALUE;
              IF N LS 0  THEN 
                  N = -N; 
              IF N GR 999999999 THEN
                  BEGIN 
                  C10PLUS = " *********          "; 
                  I = 0;
                  END 
              ELSE
                  BEGIN 
                  FOR I = 9 WHILE N NQ 0  DO
                      BEGIN 
                      C<I,1>C10PLUS = N - (N/10)*10 + 27; 
                      N = N/10; 
                      I = I - 1;
                      END 
                  END 
              IF VALUE LS 0 THEN
                  C<I,1>C10PLUS = "-";
              DEC = C<I,10>C10PLUS; 
              END  # DEC #
  
  
          VCOUNT = 0; 
  
TOPSSC: 
  
#           GET THE NEXT TOKEN, ADVANCE ALL POINTERS AND               #
#           ...THEN CHECK FOR 'EOS' OR ILLEGAL CHARACTERS              #
  
          S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
  
          IF TOKENTYPE EQ  TYP"EOS"   THEN
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              IF PARORD NQ 0 THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$29,STRING$,PTR); # PARANETHESES MUST BE    #
#                    MATCHED IN THE PARAMETER-LIST                     #
                  STATUS$NORML = FALSE; 
                  END 
#***#         RETURN; 
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"SPACE" THEN
#***#         GOTO TOPSSC;
  
          ELSE
          IF TOKENTYPE EQ  TYP"RP" THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              PARORD = PARORD - 1;
                  $BEGIN
#??#              MES = " SSC PARORD = "; 
#??#              C<13,10>MES = DEC(PARORD);
#??#              S$PRTCD(MES); 
#??#              S$PRTCD(0); 
                  $END
              IF PARORD LQ 0 THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$29,STRING$,PTR); # PARANETHESES MUST BE    #
#                    MATCHED IN THE PARAMETER-LIST                     #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF PARORD EQ 1 THEN 
                  BEGIN 
                  IF VCOUNT LS PDT$MINV[KN]   THEN
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$34,STRING$,PTR);  # TOO FEW VALUES     #
#                        IN THE VALUE-SET ENDED HERE                   #
                      STATUS$NORML = FALSE; 
#***#                 RETURN; 
                      END 
                  ELSE
#***#                 RETURN; # FOR SET IS COMPLETELY SCANNED          #
                  END 
              ELSE # IF PARORD GR 1 THEN                               #
#***#             GOTO TOPSSC;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"LP" THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              PARORD = PARORD + 1;
                  $BEGIN
#??#              MES = " SSC PARORD = "; 
#??#              C<13,10>MES = DEC(PARORD);
#??#              S$PRTCD(MES); 
#??#              S$PRTCD(0); 
                  $END
              IF PARORD GR 2   THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$25,STRING$,PTR);  # UNLESS "$CHAR(N)" IS   #
#                    USED, ONLY ONE SET OF NESTED PARENTHESES IS       #
#                    ALLOWED                                           #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOPSSC;
                  END 
              $BEGIN
              IF PARORD LQ 2 THEN      # THERE IS AN ERROR IN SSC      #
                  S$ABORT("S$SSC-1"); 
              $END
              IF PARORD EQ 2  THEN
#***#             GOTO TOPSSC;
              END # OF TYP = "LP"                                      #
  
          ELSE
          IF TOKENTYPE EQ  TYP"NUM"  THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              IF PDT$VALT[KN] NQ VALTYP"INTEGER"   AND   PDT$VALT[KN] 
                    NQ VALTYP"ANY"   THEN 
                  BEGIN 
                  IF PDT$VALT[KN] EQ VALTYP"NAME"  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$27,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE A FILE(OR ENTRY-POINT) NAME         #
                      STATUS$NORML = FALSE; 
                      END 
                  IF PDT$VALT[KN] EQ VALTYP"STRING"  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$11,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE A STRING(DELIMITED BY "..")         #
                      STATUS$NORML = FALSE; 
                      END 
                  END 
  
              IF TOKENPRVT EQ TYP"COMMA"  OR  TOKENPRVT EQ
                              TYP"LP"  # AND NOT ".." #   THEN
                  VCOUNT = VCOUNT + 1;
              ELSE # THIS TOKEN IS THE UPPERBOUND OF A RANGE           #
#***#             GOTO TOPSSC;
  
              IF VCOUNT GR PDT$MAXV[KN]  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$33,STRING$,PTR);  # TOO MANY VALUES        #
#                   SPECIFIED IN THE VALUE-SET                         #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOPSSC;
                  END 
              ELSE
#***#             GOTO TOPSSC;
              END # OF TYP = "NUM"                                     #
  
          ELSE # OF "IF TOKENTYPE EQ  ..." #
          IF TOKENTYPE EQ  TYP"NAME"  OR TOKENTYPE EQ  TYP"$NAM"  THEN
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              IF PDT$VALT[KN] NQ VALTYP"NAME"   OR  PDT$VALT[KN] NQ 
                    VALTYP"ANY"    THEN 
                  BEGIN 
                  IF PDT$VALT[KN] EQ VALTYP"INTEGER"  THEN
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$32,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE AN INTEGER                          #
                      STATUS$NORML = FALSE; 
                      END 
                  IF PDT$VALT[KN] EQ VALTYP"STRING"  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$11,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE A STRING(DELIMITED BY "..")         #
                      STATUS$NORML = FALSE; 
                      END 
  
                  END 
  
              IF TOKENPRVT EQ TYP"COMMA"  OR  TOKENPRVT EQ
                              TYP"LP"  # AND NOT ".." #   THEN
                  VCOUNT = VCOUNT + 1;
              ELSE  # THIS TOKEN IS THE UPPER BOUND OF A RANGE         #
#***#             GOTO TOPSSC;
              IF VCOUNT GR PDT$MAXV[KN]  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$31,STRING$,PTR);  # TOO MANY VALUE-SETS    #
#                    GIVEN FOR THIS KEYWORD-VALUE-LIST                 #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOPSSC;
                  END 
              ELSE
#***#             GOTO TOPSSC;
              END # OF TYP = NAME                                      #
  
          ELSE
          IF TOKENTYPE EQ  TYP"STRING"  THEN
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              IF PDT$VALT[KN] NQ VALTYP"STRING"  AND  PDT$VALT[KN] NQ 
                    VALTYP"ANY"   THEN
                  BEGIN 
                  IF PDT$VALT[KN] EQ VALTYP"NAME"  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$27,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE A FILE(OR ENTRY-POINT) NAME         #
                      STATUS$NORML = FALSE; 
                      END 
                  IF PDT$VALT[KN] EQ VALTYP"INTEGER"  THEN
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$32,STRING$,PTR);  # THIS VALUE         #
#                        SHOULD BE AN INTEGER                          #
                      STATUS$NORML = FALSE; 
                      END 
                  END 
              IF TOKENPRVT NQ TYP"ELLIPSIS"  THEN 
                  VCOUNT = VCOUNT + 1;
              ELSE  #   THIS TOKEN IS THE UPPER BOUND OA R RANGE       #
#***#             GOTO TOPSSC;
              IF VCOUNT GR PDT$MAXV[KN]  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$33,STRING$,PTR);  # TOO MANY VALUES        #
#                   SPECIFIED IN THE VALUE-SET                         #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOPSSC;
                  END 
              ELSE
#***#             GOTO TOPSSC;
              END # OF TYP = STRING                                    #
  
          ELSE
          IF TOKENTYPE EQ  TYP"COMMA"  THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              IF TOKENPRVT EQ  TYP"COMMA" # NOT AN ERROR IN S$CKPRVT   #
                        THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$22,STRING$,PTR);  # POSITIONAL VALUES      #
#                    ARE NOT ALLOWED IN A VALUE-SET                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOPSSC;
                  END 
              ELSE
#***#             GOTO TOPSSC;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"EQUALS"  THEN
              BEGIN 
              PTR = PREVCOL;
              S$ERROR(E$26,STRING$,PTR); # UNLESS WITHIN A STRING      #
#                NEITHER . OR = IS ALLOWED WITHIN A VALUE-SET          #
              STATUS$NORML = FALSE; 
#***#         GOTO TOPSSC;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"DOT"   THEN
              BEGIN 
              PTR = PREVCOL;
              S$ERROR(E$26,STRING$,PTR);  # UNLESS IN A STRING,NEITHER #
#                . NOR = IS ALLOWED WITHIN A VALUE-SET                 #
#***#         GOTO TOPSSC;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"ELLIPSIS"  THEN
              BEGIN 
              IF TOKENPRVT NQ TYP"NUM" AND TOKENPRVT NQ TYP"STRING" AND 
                    TOKENPRVT NQ TYP"NAME"   THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$19,STRING$,PTR);   # THE HIGH AND LOW      #
#                    VALUES OF THIS RANGE MUST BE AN INTEGER,          #
#                    R1,R2 OR R3                                       #
                  STATUS$NORML = FALSE; 
                  END 
              ELSE # CHECK TO SEE IF RANGE IS ALLOWED AS A VALUE       #
                  BEGIN 
                  IF PDT$VRA[KN]  THEN
#***#                 GOTO TOPSSC;
                  ELSE # IF VALUE_RANGE NOT ALLOWED THEN               #
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$24,STRING$,PTR); # A RANGE IS          #
#                        ONLY ALLOWED FOR ENR,KEY AND SUM              #
#                        PARAMETERS                                    #
                      STATUS$NORML = FALSE; 
 #***#                GOTO TOPSSC;
                      END 
                  END 
              END 
  
  
          END # OF S$SSC #
          TERM
