*DECK CLP$SPL 
          PROC CLP$SPL(STRING$,PDT$,STATUS$); 
  
#**       CLP$SPL -   SCAN STRING(PARAMETER LIST) FOR PARAMETERS       #
#                                                                      #
#       CALLING SEQ -                                                  #
#         CLP$SPL(STRING$,PDT$,STATUS$):                               #
#       GIVEN -                                                        #
#         PDT$    = PARAMETER DESCRIPTION TABLE                        #
#         STATUS$ = EXPANDED ERROR STATUS(OUTPUT)                      #
#         STRING$ = ARRAY WHICH CONTAINS STRING AND ITS LENGTH         #
#       DOES -                                                         #
#         SCAN A STRING FOR PARAMETER AS DESCRIBED IN THE PARAMETER-   #
#         DESCRIPTION-TABLE AND STORE INFORMATION ABOUT THE PARAMETER  #
#         FOR USE BY FUTURE CALLS BY OTHER CLP$-PROCS                  #
#                                                                      #
          BEGIN 
*CALL A 
  
*CALL E$
  
*CALL CLPTYPE 
  
*CALL PDT$
  
*CALL STATUS$ 
  
*CALL STRING$ 
  
*CALL CLPARRA 
  
*CALL DEBUG 
  
          XREF
              BEGIN 
*CALL PVT$
  
              ITEM  SCOUNT   U;  # NUM OF VALUE-SETS FOUND             #
              END 
  
*CALL KOL$
  
          XREF
              BEGIN 
              PROC S$ABORT; 
              PROC S$CKPRV; 
              PROC S$ERROR; 
#??#          PROC S$PRTCD; 
              PROC S$NXTOK; 
              PROC S$SVL; 
              END 
  
          ITEM CH        C(10); 
          ITEM KEYNAM    B=FALSE;      # IS NAME_TOKEN A KEYWORD       #
#??#      ITEM MES         C(60);   # USED BY S$PRTCD                  #
          ITEM IN       I;
          ITEM J           I; 
  
          XDEF
#                 INDEX FOR THE NUMBER OF PARAMETERS PROCESSED THUS FAR#
              BEGIN 
              ITEM LPN    I=0; # PARAM. POS. RELATIVE TO LAST KEYWORD  #
              ITEM PN     I=0; # PARAM. POS. WITHIN PARAMETER-LIST     #
              ITEM KN     I=0;
              END 
  
          TOKENTYPE  = TYP"NONE"; 
  
#                 INITIALIZE PVT$ ARRAY                                #
  
              FOR IN = 0 STEP 1 UNTIL 40  DO
              BEGIN 
              PVT$KEYWNAM[IN] = " ";
              PVT$KEYWNUM[IN] = 0;
              PVT$KEYWINDX[IN] = 0; 
              PVT$VALGIVEN[IN] = FALSE; 
              PVT$FINDXVAL[IN] = 0; 
              PVT$LINDXVAL[IN] = 0; 
              PVT$SETCOUNT[IN] = 0; 
              END 
  
  
#           FOR DEBUGGING ONLY                                         #
#                                                                      #
  
          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 #
  
  
          ITEM DB      C(10); 
  
#                                                                      #
#           * * * * * * * * *                                          #
CONTROL EJECT;
  
          TOKENC = "          ";
          TOKENPRVT = TYP"NONE";
          COL = 0;
          PREVCOL = 0;
          PN = 1; 
          LPN = 1;
  
  
  
TOP:  
  
          S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
  
#           CHECK THE PREVIOUS TYPE FOR SYNTAX ERRORS                  #
  
          S$CKPRV(STRING$,COL$,TOKEN$,STATUS$); 
  
  
          IF TOKENTYPE EQ  TYP"EOS" THEN
              BEGIN 
#***#         RETURN; 
              END 
  
#           LOOK AT TOKENTYPE  AND DETERMINE WHAT ACTION TO TAKE       #
  
          KEYNAM = FALSE; 
  
  
          IF ( TOKENTYPE EQ TYP"NAME" ) 
                      OR
             ( TOKENTYPE EQ TYP"$NAM" ) THEN
              BEGIN 
  
#               GATHER MORE INFORMATION ABOUT THIS NAME TOKEN          #
  
              FOR KN=1 STEP 1 UNTIL PDT$LEN DO
                  BEGIN 
                  IF TOKENC EQ PDT$NAME[KN] THEN
                    BEGIN 
                    KOL = COL;
                    PREVKOL = PREVCOL;
                    NXT$TYP[0] = TOKENTYPE; 
                    NXT$PT[0]  = TOKENPRVT; 
  
#                     LOOK TO SEE IF THE TOKEN AFTER THIS NAME IS A    #
#                     COMMA IF SO THEN THIS NAME TOKEN IS A POSITIONAL #
#                     VALUE - EVEN THOUGH IT IS ALSO A KEYWORD.        #
#                     FOR EXAMPLE, IN:  'SORT5.FROM=OLD,DIR,KEY=10'    #
#                     'DIR' IS THE POSITIONAL VALUE OF THE TO-FILE     #
#                                                                      #
  
GTNT: 
  
                    S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                    IF NXT$TYP[0] EQ TYP"SPACE"  THEN 
#***#                 GOTO GTNT;
                    ELSE
                    IF NXT$TYP[0] EQ TYP"COMMA"  THEN 
                      KEYNAM = FALSE; 
                    ELSE
                    IF NXT$TYP[0] NQ TYP"SPACE"  AND
                        NXT$TYP[0] NQ TYP"COMMA" AND
                         NXT$TYP[0] NQ TYP"EOS"  THEN 
                      BEGIN 
                      KEYNAM = TRUE;
                      LPN = PDT$POSN[KN]; 
                      $BEGIN
                      DB = DEC(LPN);
                      MES = " *** CHANGE LPN TO ";
                      C<19,10>MES = DB; 
                      S$PRTCD(MES); 
                      FLUSH;
                      $END
                      GOTO TESTKEYW;
                      END 
                    END 
#                   OTHERWISE CONTINUE LOOP                            #
                  END 
  
TESTKEYW: 
  
              IF # TOKEN IS # KEYNAM THEN 
                  BEGIN 
                  PVT$KEYWNAM[PN] = TOKENC; 
                  PVT$KEYWNUM[PN] = KN; 
                  PVT$KEYWINDX[PN] = PREVCOL; 
  
GTNX: 
#                   GET THE NEXT TOKEN                                 #
  
                  S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                  IF TOKENTYPE EQ TYP"SPACE"  THEN
#***#                 GOTO GTNX;
  
#                   DEPENDING UPON WHAT FOLLOWS THE KEYWORD,DO :       #
                  ELSE
                  IF TOKENTYPE EQ  TYP"EQUALS" THEN 
                      BEGIN 
                      PVT$FINDXVAL[PN] = COL;  # COLUMN AFTER =        #
                      S$SVL(STRING$,COL$,PDT$,TOKEN$,KN,STATUS$); 
                      PVT$VALGIVEN[PN] = TRUE;
                      PVT$LINDXVAL[PN] = COL-1; 
                      PVT$SETCOUNT[PN] = SCOUNT;
                      PN = PN + 1;
                      LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
                      IF TOKENTYPE EQ TYP"EOS"  THEN
#***#                     RETURN; 
                      ELSE
#***#                     GOTO TOP; 
                      END 
  
                  ELSE # IF TOKEN TYPE IS NONE OF THE ABOVE            #
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$5,STRING$,PTR); # CHRACTER AFTER       #
#                        KEYWORD MUST BE SPACE = OR ,                  #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
                  END 
  
  
          IF #TOKEN IS # NOT KEYNAM  THEN 
              BEGIN 
  
#               SINCE POSITIONAL PARAMETERS ARE ALLOWED                #
#               THEN THE ADDITIONAL CASES OF TOKEN_NQ_KEYNAM ,         #
#               THAT FOLLOW BELOW FOR TOKENTYPE = NAME, ARE TESTED.    #
  
                  BEGIN 
                  IF LPN GR PDT$HIGHEST  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$15,STRING$,PTR);  # TOO MANY PARAMETER #
#                        POSITIONS HAVE BEEN SPECIFIED                 #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
#                   LOOK FOR PDT$POSN = LPN                            #
                  FOR KN=1 STEP 1 UNTIL PDT$LEN DO
                      BEGIN 
                      IF PDT$POSN[KN] EQ LPN  THEN
#***#                     GOTO LB3; 
#                       CONTINUE LOOP                                  #
                      END 
  
#                   IF LPN CAN NOT BE FOUND WITHIN THE VALUES OF       #
#                           PDT$POSN[X] THEN IT IS GREATER THAN        #
#                           ANY POSITION NUMBER ALLOWED                #
  
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
  
LB3:  
  
                  IF PDT$MINV[KN] GR 1  THEN
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$34,STRING$,PTR);  # TOO FEW VALUES     #
#                        SPECIFIED IN THIS VALUE-SET                   #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      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; 
#***#                 GOTO TOP; 
                      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 WITH "..")              #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
                  PVT$KEYWNAM[PN] = PDT$NAME[KN]; 
                  PVT$KEYWNUM[PN] = KN; 
                  PVT$KEYWINDX[PN] = 0; 
                  PVT$VALGIVEN[PN] = TRUE;
                  PVT$FINDXVAL[PN] = PREVCOL; 
  
                  IF NOT PDT$VRA[KN]   THEN 
#                   RANGE IS NOT ALLOWED FOR THIS VALUE                #
                      BEGIN 
                      PVT$LINDXVAL[PN] = COL - 1; 
                      PVT$SETCOUNT[PN] = 1; 
                      PN = PN + 1;
                      LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
                      IF TOKENTYPE EQ TYP"EOS"  THEN
#***#                     RETURN; 
                      ELSE
#***#                     GOTO TOP; 
                      END 
  
#                   OTHERWISE A RANGE FOR THIS VALUE IS ALLOWED        #
#                          SO DO THE FOLLOWING                         #
  
CONTROL FASTLOOP; 
  
                  FOR J=J WHILE TOKENTYPE EQ TYP"SPACE"  DO 
                      BEGIN 
                      S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                      IF NOT STATUS$NORML  THEN 
#***#                     RETURN; 
                      END 
  
CONTROL SLOWLOOP; 
  
                  IF TOKENTYPE NQ TYP"ELLIPSIS"  THEN 
                    BEGIN 
                    IF TOKENTYPE EQ TYP"EQUALS"  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$7,STRING$,PTR);  # UNLESS IN A STRING, #
#                        = XHOULD FOLLOW A KEYWORD                     #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
                    ELSE
                      BEGIN 
                      PVT$LINDXVAL[PN] = PREVCOL -1;
                      PVT$SETCOUNT[PN] = 1; 
                      PN = PN + 1;
                      LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
                          IF TOKENTYPE EQ TYP"EOS"   THEN 
#***#                         RETURN; 
                          ELSE
#***#                         GOTO TOP; 
                      END 
                    END 
  
                  IF TOKENTYPE EQ TYP"ELLIPSIS"  THEN 
                      BEGIN 
                      IF NOT PDT$VRA[KN] THEN   # RANGE IS NOT ALLOWED #
                          BEGIN 
                          PTR = PREVCOL;
                          S$ERROR(E$24,STRING$,PTR);  # A RANGE IS ONLY#
#                            ALLOWED FOR ENR,KEY OR SUM PARAMETERS     #
                          STATUS$NORML = FALSE; 
#***#                     GOTO TOP; 
                          END 
  
#                       OTHERWISE RANGE IS ALLOWED                     #
  
  
CONTROL FASTLOOP; 
  
                      FOR J=J WHILE TOKENTYPE EQ TYP"SPACE"  DO 
                          BEGIN 
                          S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                          IF NOT STATUS$NORML  THEN 
#***#                         RETURN; 
                          END 
  
CONTROL SLOWLOOP; 
  
                      IF (TOKENTYPE NQ TYP"NAME" AND
                          TOKENTYPE NQ TYP"NUM")   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 TOP; 
                          END 
                      END 
  
#                     IF THIS POINT IS REACHED, THE RANGE              #
#                     SPECIFIED FOR THIS PARAMETER IS VALID            #
  
                  PVT$LINDXVAL[PN] = COL - 1; 
                  PVT$SETCOUNT[PN] = 1; 
                  PN = PN + 1;
                  LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO TOP; 
                  END 
  
  
                END # OF TOKENTYPE NQ KEYNAME                          #
  
              END # OF TYPE = 'NAME'                                   #
  
          ELSE
          IF TOKENTYPE EQ  TYP"COMMA" THEN
              BEGIN 
  
              IF TOKENPRVT NQ  TYP"COMMA"  AND
                      TOKENPRVT NQ  TYP"NONE"  THEN 
                  BEGIN 
#***#             GOTO TOP; 
                  END 
              IF TOKENPRVT EQ TYP"COMMA" OR TOKENPRVT EQ TYP"NONE" THEN 
                BEGIN 
                IF LPN GR PDT$HIGHEST  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
                  END 
  
#                   SINCE POSITIONAL PARAMETERS ARE ALLOWED            #
#                   SET APPROPRIATE PVT VALUE AS BEING DEFAULT         #
  
                      BEGIN 
                      FOR KN=1 STEP 1 UNTIL PDT$LEN DO
                          BEGIN 
                          IF PDT$POSN[KN] EQ LPN  THEN
#***#                         GOTO P3;
#                           CONTINUE LOOP                              #
                          END 
  
#                       IF LPN CAN NOT BE FOUND WITHIN THE VALUES OF   #
#                               PDT$POSN[X] THEN IT IS GREATER THAN    #
#                               ANY POSITION NUMBER ALLOWED            #
  
                      PTR = PREVCOL;
                      S$ERROR(E$15,STRING$,PTR);  # TOO MANY PARAMETER #
#                        POSITIONS HAVE BEEN SPECIFIED                 #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
  
P3: 
                      PVT$KEYWNAM[PN] = PDT$NAME[KN]; 
                      PVT$KEYWNUM[PN]=KN; 
                      PVT$KEYWINDX[PN]=0; 
                      PVT$SETCOUNT[PN]=0; 
                      PN = PN + 1;
                      LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
                      END 
#***#             GOTO TOP; 
                  END 
              END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"LP" THEN 
                  BEGIN 
                  IF LPN GR PDT$HIGHEST  THEN 
                      BEGIN 
                      PTR = PREVCOL;
                      S$ERROR(E$15,STRING$,PTR);  # TOO MANY PARAMETER #
#                         POSITIONS HAVE BEEN SPECIFIED                #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
                  FOR KN=1 STEP 1 UNTIL PDT$LEN  DO 
                      BEGIN 
                      IF PDT$POSN[KN] EQ LPN  THEN
#***#                     GOTO P4;
#                       CONTINUE LOOP                                  #
                      END 
  
#                   IF LPN CAN NOT BE FOUND WITHIN THE VALUES OF       #
#                           PDT$POSN[X] THEN IT IS GREATER THAN        #
#                           ANY POSITION NUMBER ALLOWED                #
  
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
P4: 
                  PVT$KEYWNAM[PN] = PDT$NAME[KN]; 
                  PVT$KEYWNUM[PN] = KN; 
                  PVT$KEYWINDX[PN] = 0; 
L1: 
                  COL = PREVCOL;  # HAVE COL POINTING TO 'LP' AGAIN    #
                  PVT$FINDXVAL[PN] = COL; 
                  S$SVL(STRING$,COL$,PDT$,TOKEN$,KN,STATUS$); 
                  PVT$VALGIVEN[PN] = TRUE;
                  PVT$LINDXVAL[PN] = COL-1; 
                  PVT$SETCOUNT[PN] = SCOUNT;
                  PN = PN + 1;
                  LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
                  IF TOKENTYPE EQ TYP"EOS"  THEN
#***#                 RETURN; 
                  ELSE
#***#                 GOTO TOP; 
                  END 
  
          ELSE
          IF TOKENTYPE EQ  TYP"SPACE" THEN
              BEGIN 
              IF TOKENTYPE EQ TYP"EOS"  THEN
#***#             RETURN; 
              ELSE
#***#             GOTO TOP; 
              END 
  
          ELSE
          IF TOKENTYPE EQ TYP"NUM"  THEN
            BEGIN 
            IF LPN GR PDT$HIGHEST  THEN 
              BEGIN 
              PTR = PREVCOL;
              S$ERROR(E$15,STRING$,PTR);      # TOO MANY PARAMETER     #
  #               POSITIONS HAVE BEEN SPECIFIED                        #
              STATUS$NORML = FALSE; 
#***#         GOTO TOP; 
              END 
  
#                   LOOK FOR PDT$POSN = LPN                            #
  
                  FOR KN=1 STEP 1 UNTIL PDT$LEN DO
                      BEGIN 
                      IF PDT$POSN[KN] EQ LPN  THEN
#***#                     GOTO LB1; 
#                       CONTINUE LOOP                                  #
                      END 
  
#                   IF LPN CAN NOT BE FOUND WITHIN THE VALUES OF       #
#                           PDT$POSN[X] THEN IT IS GREATER THAN        #
#                           ANY POSITION NUMBER ALLOWED                #
  
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
  
LB1:  
  
                  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; 
#***#                 GOTO TOP; 
                      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 WITH "..")              #
                      STATUS$NORML = FALSE; 
#***#                 GOTO TOP; 
                      END 
                  PVT$KEYWNAM[PN] = PDT$NAME[KN]; 
                  PVT$KEYWNUM[PN] = KN; 
                  PVT$KEYWINDX[PN] = 0; 
                  PVT$VALGIVEN[PN] = TRUE;
                  PVT$FINDXVAL[PN] = PREVCOL; 
  
                  S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                  IF NOT STATUS$NORML THEN
#***#                 RETURN; 
  
#                   IF TOKENTYPE NQ ELLIPSIS OR COMMA THEN THIS ERROR  #
#                           SHOULD HAVE BEEN CAUGHT BY S$CKPRV         #
  
                  IF TOKENTYPE EQ TYP"ELLIPSIS"  THEN 
                      BEGIN 
                      IF NOT PDT$VRA[KN] THEN   # RANGE IS NOT ALLOWED #
                          BEGIN 
                          PTR = PREVCOL;
                          S$ERROR(E$24,STRING$,PTR);  # A RANGE IS ONLY#
#                            ALLOWED FOR ENR,KEY OR SUM PARAMETERS     #
                          STATUS$NORML = FALSE; 
#***#                     GOTO TOP; 
                          END 
  
#                       OTHERWISE RANGE IS ALLOWED                     #
  
                      S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                      IF NOT STATUS$NORML  THEN 
#***#                     RETURN; 
                      IF (TOKENTYPE NQ TYP"NAME" AND
                          TOKENTYPE NQ TYP"NUM")   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 TOP; 
                          END 
                      END 
  
#                     IF THIS POINT IS REACHED, THE RANGE              #
#                     SPECIFIED FOR THIS PARAMETER IS VALID            #
  
                  PVT$LINDXVAL[PN] = COL - 1; 
                  PVT$SETCOUNT[PN] = 1; 
                  PN = PN + 1;
                  LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO TOP; 
            END 
  
  
          ELSE
          IF TOKENTYPE EQ TYP"STRING"  THEN 
              BEGIN 
              IF LPN GR PDT$HIGHEST  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
                  END 
  
#                   LOOK FOR PDT$POSN = LPN                            #
                  FOR KN=1 STEP 1 UNTIL PDT$LEN DO
                      BEGIN 
                      IF PDT$POSN[KN] EQ LPN  THEN
#***#                     GOTO LB2; 
#                       CONTINUE LOOP                                  #
                      END 
  
#                   IF LPN CAN NOT BE FOUND WITHIN THE VALUES OF       #
#                           PDT$POSN[X] THEN IT IS GREATER THAN        #
#                           ANY POSITION NUMBER ALLOWED                #
  
                  PTR = PREVCOL;
                  S$ERROR(E$15,STRING$,PTR);    # TOO MANY PARAMETER   #
#                     POSITIONS HAVE BEEN SPECIFIED                    #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
  
LB2:  
  
                  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; 
#***#                 GOTO TOP; 
                      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; 
#***#                 GOTO TOP; 
                      END 
                  PVT$KEYWNAM[PN] = PDT$NAME[KN]; 
                  PVT$KEYWNUM[PN] = KN; 
                  PVT$KEYWINDX[PN] = 0; 
                  PVT$VALGIVEN[PN] = TRUE;
                  PVT$FINDXVAL[PN] = PREVCOL; 
  
                  S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                  IF NOT STATUS$NORML THEN
#***#                 RETURN; 
  
#                   IF TOKENTYPE NQ ELLIPSIS OR COMMA THEN THIS ERROR  #
#                           SHOULD HAVE BEEN CAUGHT BY S$CKPRV         #
  
                  IF TOKENTYPE EQ TYP"ELLIPSIS"  THEN 
                      BEGIN 
                      IF NOT PDT$VRA[KN] THEN   # RANGE IS NOT ALLOWED #
                          BEGIN 
                          PTR = PREVCOL;
                          S$ERROR(E$24,STRING$,PTR);  # A RANGE IS ONLY#
#                            ALLOWED FOR ENR,KEY OR SUM PARAMETERS     #
                          STATUS$NORML = FALSE; 
#***#                     GOTO TOP; 
                          END 
  
#                       OTHERWISE RANGE IS ALLOWED                     #
  
                      S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
                      IF NOT STATUS$NORML  THEN 
#***#                     RETURN; 
                      IF TOKENTYPE NQ TYP"STRING"   THEN
                          BEGIN 
                          PTR = PREVCOL;
                          S$ERROR(E$20,STRING$,PTR);  # THE HIGH       #
#                            AND LOW VALUES OF THIS RANGE MUST BE      #
#                            A STRING                                  #
                          STATUS$NORML = FALSE; 
#***#                     GOTO TOP; 
                          END 
                      END 
  
#                     IF THIS POINT IS REACHED, THE RANGE              #
#                     SPECIFIED FOR THIS PARAMETER IS VALID            #
  
                  PVT$LINDXVAL[PN] = COL - 1; 
                  PVT$SETCOUNT[PN] = 1; 
                  PN = PN + 1;
                  LPN = LPN + 1;
              $BEGIN
              DB = DEC(PN); 
              MES = " *** INCREMENT PN  TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              DB = DEC(LPN);
              MES = " *** INCREMENT LPN TO "; 
              C<21,10>MES = DB; 
              S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO TOP; 
            END 
  
  
          ELSE   # IF TOKEN IS NONE OF THE ABOVE TYPES THEN            #
              BEGIN 
              IF TOKENTYPE EQ TYP"DOT"  THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$23,STRING$,PTR);  # A PEROID CAN NOT       #
#                    BE USED IN A PARAMETER-LIST                       #
#***#             GOTO TOP; 
                  END 
  
              ELSE
              IF TOKENTYPE EQ TYP"EQUALS"  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$7,STRING$,PTR);  # UNLESS IN A STRING, =   #
#                    SHOULD FOLLOW ONLY A KEYWORD                      #
                  STATUS$NORML = FALSE; 
 #***#            GOTO TOP; 
                  END 
              ELSE
              IF TOKENTYPE EQ TYP"RP"   THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$29,STRING$,PTR);  # PARENTHESIS MUST BE    #
#                    MATCHED IN A PARAMETER-LIST                       #
                  STATUS$NORML = FALSE; 
#***#             GOTO TOP; 
                  END 
  
#               ELSE FOR ANY OTHER TOKEN  ?$!&*@&                      #
  
#               POTENTIAL TROUBLE SPOT, IT IS NOT FULLY TESTED         #
  
              PTR = PREVCOL;
              S$ERROR(E$13,STRING$,PTR);  # THIS COMMA SHOULD BE       #
#                FOLLOWED BY A LETTER,DIGIT,SPACE , OR (               #
              STATUS$NORML = FALSE; 
#***#         GOTO TOP; 
              END 
  
          END # OF CLP$SPL #
          TERM
