*DECK S$SVL 
          PROC S$SVL(STRING$,COL$,PDT$,TOKEN$,KN,STATUS$);
  
#**       SVL - SCAN_VALUE_LIST(TEXT)                                  #
#                                                                      #
#       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 -                                                         #
#           THIS ROUTINE IS CALLED TO SEARCH THE TOKENS IMMEDIATELY    #
#         AFTER A KEYWORD AND 'EQUALS' SIGN ARE FOUND OR A POSITION    #
#         PARAMETER SURROUNDED BY PARENTHESES IS FOUND.                #
#           THIS ROUTINE IS USED TO DETERMINE:  IF THE VALUE GIVEN IS  #
#         OF THE PROPER TOKEN TYPE, AND WHAT THE STARTING AND ENDING   #
#         POSITIONS(INDICES) ARE WITHIN THE GIVEN TEXT FOR THIS VALUE  #
#                                                                      #
  
          BEGIN 
  
          XDEF
              BEGIN 
              ITEM     PARORD   I;  # PARENTHESIS ORDER                #
              ITEM     PAREN    B;  # HAS PARENTHESIS BEEN FOUND       #
              ITEM     SCOUNT   U;  # NUM OF VAL-SETS SCANNED THUS FAR #
              END 
  
  
          XREF
              BEGIN 
              PROC S$ABORT; 
              PROC S$ERROR; 
              PROC S$CKPRV; 
              PROC S$NXTOK; 
              PROC S$PRTCD;     # PRINT A LINE TO THE FILE CODE        #
              PROC S$SSC; 
              END 
  
*CALL A 
  
*CALL E$
  
*CALL CLPTYPE 
  
          XREF
              BEGIN 
*CALL PVT$
              END 
  
*CALL PDT$
  
          ITEM    KN    I;         # KEYW. NUM. WITHIN PDT$            #
          ITEM MES    C(80);   # USED BY S$PRTCD                       #
  
          XREF
              BEGIN 
              ITEM     PN    I;    # PARAMETER NUM.                    #
              END 
  
  
*CALL STRING$ 
  
*CALL CLPARRA 
  
*CALL STATUS$ 
  
  
          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 #
  
  
  
          PARORD = 0; 
          PAREN = FALSE;
          SCOUNT = 0; 
  
  
TOPSVL: 
  
#           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 TOPSVL;
  
          ELSE
          IF TOKENTYPE EQ  TYP"RP" THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              PARORD = PARORD - 1;
                  $BEGIN
#??#              MES = " SVL PARORD = "; 
#??#              C<13,10>MES = DEC(PARORD);
#??#              S$PRTCD(MES); 
#??#              S$PRTCD(0); 
                  $END
              IF PARORD LS 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 0 THEN 
                  BEGIN 
                  IF PAREN # HAS BEEN USED WITHIN THIS VALUE #  THEN
                      BEGIN 
                      IF SCOUNT LS PDT$MINS[KN]   THEN
                          BEGIN 
                          PTR = PREVCOL;
                          S$ERROR(E$30,STRING$,PTR); # TOO FEW SETS    #
#                            GIVEN FOR THIS KEYWORD-VALUE-LIST         #
#                            ENDED HERE                                #
                          STATUS$NORML = FALSE; 
                          END 
                      ELSE
                      PAREN = FALSE;
#***#                 GOTO TOPSVL;
                      END 
  
                      $BEGIN
                      IF NOT PAREN  THEN
#                       THERE IS AN ERROR IN DESIGN                    #
                          BEGIN 
                          S$ABORT("S$SVL-1"); 
                          END 
                      $END
                  END 
              ELSE # IF PARORD GR 0 THEN                               #
#***#             GOTO TOPSVL;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"LP" THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
              PARORD = PARORD + 1;
                  $BEGIN
#??#              MES = " SVL 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 TOPSVL;
                  END 
              ELSE
              IF PARORD EQ 1   THEN 
                  BEGIN 
                  PAREN = TRUE; 
#***#             GOTO TOPSVL;
                  END 
              ELSE # IF PARORD EQ 2                                    #
                  BEGIN 
                  SCOUNT = SCOUNT + 1;
                  IF SCOUNT GR PDT$MAXS[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 TOPSVL;
                      END 
                  ELSE # IF SCOUNT LESS THAN PDTMAXS                   #
                  S$SSC(STRING$,COL$,PDT$,TOKEN$,KN,STATUS$); 
#***#             GOTO TOPSVL;
                  END 
              END # OF TYP = "LP"                                      #
  
          ELSE
          IF TOKENTYPE EQ  TYP"NUM"  THEN 
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
  
  
#                TEST THAT MIN AND MAX VALUES ALLOWED = 1              #
              IF PDT$MINV[KN] GR 1  THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$34,STRING$,PTR); # TOO FEW VALUES          #
#                    SPECIFIED IN THE VALUE-SET ENDED HERE             #
                  STATUS$NORML = FALSE; 
                  END 
              IF PDT$MINS[KN] EQ 0  OR  PDT$MAXS[KN] EQ 0   THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$33,STRING$,PTR);  # TOO MANY VALUES        #
#                   SPECIFIED IN THE VALUE-SET                         #
                  STATUS$NORML = FALSE; 
                  END 
#               IF MINV EQ 1 OR MAXV GE 1 THEN VALUE IS PROPER         #
  
  
              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 NQ TYP"ELLIPSIS"  THEN 
                  SCOUNT = SCOUNT + 1;
              ELSE # THIS TOKEN IS THE UPPERBOUND OF A RANGE           #
#***#             GOTO TOPSVL;
  
              IF SCOUNT GR PDT$MAXS[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 TOPSVL;
                  END 
              ELSE
#***#             GOTO TOPSVL;
              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$); 
  
#                TEST THAT MIN AND MAX VALUES ALLOWED = 1              #
              IF PDT$MINV[KN] GR 1  THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$34,STRING$,PTR); # TOO FEW VALUES          #
#                    SPECIFIED IN THE VALUE-SET ENDED HERE             #
                  STATUS$NORML = FALSE; 
                  END 
              IF PDT$MINS[KN] EQ 0  OR  PDT$MAXS[KN] EQ 0   THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$33,STRING$,PTR);  # TOO MANY VALUES        #
#                   SPECIFIED IN THE VALUE-SET                         #
                  STATUS$NORML = FALSE; 
                  END 
#               IF MINV EQ 1 OR MAXV GE 1 THEN VALUE IS PROPER         #
  
              IF PDT$VALT[KN] NQ VALTYP"NAME"  AND  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 NQ TYP"ELLIPSIS"  THEN 
                  SCOUNT = SCOUNT + 1;
              ELSE  #   THIS TOKEN IS THE UPPER BOUND OA R RANGE       #
#***#             GOTO TOPSVL;
              IF SCOUNT GR PDT$MAXS[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 TOPSVL;
                  END 
              ELSE
#***#             GOTO TOPSVL;
              END # OF TYP = NAME                                      #
  
          ELSE
          IF TOKENTYPE EQ  TYP"STRING"  THEN
              BEGIN 
              S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
#                TEST THAT MIN AND MAX VALUES ALLOWED = 1              #
              IF PDT$MINV[KN] GR 1  THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$34,STRING$,PTR); # TOO FEW VALUES          #
#                    SPECIFIED IN THE VALUE-SET ENDED HERE             #
                  STATUS$NORML = FALSE; 
                  END 
              IF PDT$MINS[KN] EQ 0  OR  PDT$MAXS[KN] EQ 0   THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$33,STRING$,PTR);  # TOO MANY VALUES        #
#                   SPECIFIED IN THE VALUE-SET                         #
                  STATUS$NORML = FALSE; 
                  END 
#               IF MINV EQ 1 OR MAXV GE 1 THEN VALUE IS PROPER         #
              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 
                  SCOUNT = SCOUNT + 1;
              ELSE  #   THIS TOKEN IS THE UPPER BOUND OA R RANGE       #
#***#             GOTO TOPSVL;
              IF SCOUNT GR PDT$MAXS[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 TOPSVL;
                  END 
              ELSE
#***#             GOTO TOPSVL;
              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; 
                  END 
              IF NOT PAREN  THEN
                  BEGIN 
#***#             RETURN; 
                  END 
              ELSE
#***#             GOTO TOPSVL;
              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 TOPSVL;
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"DOT"   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 TOPSVL;
              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; 
#***#             GOTO TOPSVL;
                  END 
              ELSE # CHECK TO SEE IF RANGE IS ALLOWED AS A VALUE       #
                  BEGIN 
                  IF PDT$VRA[KN]  THEN
#***#                 GOTO TOPSVL;
                  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 TOPSVL;
                      END 
                  END 
              END 
  
  
          END # OF S$SVL #
  
          TERM
