*DECK CLP$TR
          PROC CLP$TR(STRING$,PARAMNM,VALSETNUM,VALNUM, 
                    RANGSPEC,STATUS$);
  
#**       CLP$TR  - TESTS TO DETERMINE IF A PAR. VALUE IS A RANGE      #
#                                                                      #
#       CALLING SEQ -                                                  #
#         AS ABOVE                                                     #
#       GIVEN -                                                        #
#         PARAMNM = NAME OF PARAMETER FOR WHICH REQUEST IS MADE        #
#         RANGSPEC = IS A RANGE SPECIFIED AS THE PAR. VALUE?(OUTPUT)   #
#         STATUS$ = EXPANDED ERROR STATUS(OUTPUT)                      #
#         STRING$ = ARRAY CONTAINING A STRING AND IT'S LENGTH          #
#         VALNUM = VALUES POSITION WITHIN A SET                        #
#         VALSETNUM = VALUE-SETS POSITION WITHIN THE PARAMETER         #
#       DOES -                                                         #
#         TEST A PARTICULAR VALUE WITHIN A SET WITHIN A PARAMETER-     #
#         VALUE TO DETERMINE IF IT IS A RANGE(LOW...HIGH)              #
#                                                                      #
          BEGIN 
*CALL A 
  
*CALL CLPARAM 
  
*CALL STATUS$ 
  
*CALL STRING$ 
  
          XREF
          BEGIN 
*CALL PVT$
          END 
  
  
          XREF
              BEGIN 
              PROC S$ABORT; 
              PROC S$ERROR; 
              PROC S$GTTOK; 
              PROC S$NXTOK; 
              END 
  
          ITEM LASTCOL   I; 
          ITEM COMMANUM  I;          # NUMBER OF COMMA                 #
          ITEM PARORD    I;          # NESTED PARENTHESIS ORDER        #
          ITEM J         I; 
          ITEM SC        I;          # VALUES COUNTED THUS FAR         #
          ITEM VC        I;          # SET COUNTED THUS FAR            #
  
*CALL E$
  
*CALL CLPTYPE 
  
*CALL CLPARRA 
  
*CALL KOL$
  
          DEF PVTLENGTH   #26#; 
  
          COMMANUM = 0; 
          PARORD = 0; 
          SC = 1; 
          VC = 1; 
  
#           FIND THE PARAMNM IN THE PVT$                               #
  
          FOR J=0 STEP 1 UNTIL PVTLENGTH  DO
              BEGIN 
              IF PVT$KEYWNAM[J] EQ PARAMNM  THEN
#***#             GOTO CONL1; 
#               OTHERWISE CONTINUE LOOP                                #
              END 
  
#           IF PARAMNM WAS NOT FOUND IN THE PVT THEN                   #
          $BEGIN
          S$ABORT("CLP$TR-1");
          $END
  
CONL1:  
  
          RANGSPEC = FALSE; 
          COL = PVT$FINDXVAL[J];
          LASTCOL = PVT$LINDXVAL[J];
  
TOPTR:  
  
          IF COL GR LASTCOL  THEN 
#***#         GOTO BOTTOMTR;
          S$NXTOK(STRING$,COL$,TOKEN$,STATUS$); 
  
          IF TOKENTYPE EQ TYP"SPACE"  THEN
#***#         GOTO TOPTR; 
  
          IF TOKENTYPE EQ  TYP"NAME"  OR  TOKENTYPE EQ TYP"$NAM"  OR
                TOKENTYPE EQ  TYP"NUM"  OR TOKENTYPE EQ  TYP"STRING"
                THEN
              BEGIN 
              PREVKOL = PREVCOL;
              GOTO TOPTR; 
              END 
  
          IF TOKENTYPE EQ  TYP"ELLIPSIS"  THEN
#               A RANGE HAS BEEN FOUND                                 #
  
              BEGIN 
              IF SC EQ VALSETNUM  AND  VC EQ VALNUM  THEN 
                  BEGIN 
  
#                   CHECK TO SEE IF THE LOW AND HIGH VALUES            #
#                   OF THIS RANGE ARE OF TYP"NAME".   IF SO,           #
#                   THEN TEST THESE VALUES TO DETERMINE THAT           #
#                   THEY ARE "R1" "R2" OR "R3"                         #
  
                  KOL = PREVKOL;
  
#                   LOOK AT LOW VALUE OF RANGE                         #
  
                  S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                  LOWTOKN = NXT$CVAL[0];
                  LOWTOKNT = NXT$T; 
                  IF LOWTOKNT NQ TYP"NAME"  AND 
                              LOWTOKNT NQ TYP"STRING"  AND
                            LOWTOKNT 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; 
                      END 
                  IF LOWTOKNT EQ TYP"NAME"  THEN
                      IF LOWTOKN NQ "R1"  AND 
                             LOWTOKN NQ "R2" AND
                             LOWTOKN NQ "R3" AND
                             LOWTOKN NQ "R1G" AND 
                             LOWTOKN NQ "EF" AND
                             LOWTOKN NQ "EFG" 
                               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 
  
#                       SKIP PAST THE ELLIPSIS                         #
                      S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                      IF NXT$CVAL[0]  EQ  "  "   THEN 
                          BEGIN 
  
#                           SKIP PAST ALL BLANKS                       #
  
                          FOR J=J WHILE NXT$CVAL[0] EQ " "  DO
                              BEGIN 
                              S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                              END 
                          END 
  
#                       LOOK AT THE HIGH VALUE OF RANGE                #
  
                      S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                      IF NXT$CVAL[0]  EQ  "  "   THEN 
                          BEGIN 
  
#                           SKIP PAST ALL BLANKS                       #
  
                          FOR J=J WHILE NXT$CVAL[0] EQ " "  DO
                              BEGIN 
                              S$NXTOK(STRING$,KOL$,NXT$,STATUS$); 
                              END 
                          END 
                      HIGHTOKN = NXT$CVAL[0]; 
                      HIGHTOKNT = NXT$T;
                      IF HIGHTOKNT NQ TYP"NAME"  AND
                              HIGHTOKNT NQ TYP"STRING"  AND 
                              HIGHTOKNT 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; 
                          END 
                      IF HIGHTOKNT EQ TYP"NAME"  THEN 
                          IF HIGHTOKN NQ "R1"  AND
                              HIGHTOKN NQ "R2"  AND 
                              HIGHTOKN NQ "R3"  AND 
                              HIGHTOKN NQ "R1G" AND 
                              HIGHTOKN NQ "EF" AND
                              HIGHTOKN NQ "EFG" 
                                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 
  
                  RANGSPEC = TRUE;
                  END 
              ELSE
#***#             GOTO TOPTR; 
              END 
  
          IF TOKENTYPE EQ TYP"RP"  THEN 
              BEGIN 
              PARORD = PARORD - 1;
              IF PARORD EQ 0  THEN
#***#             GOTO BOTTOMTR;
              IF PARORD GR 0  THEN
                  BEGIN 
                  IF PARORD EQ 1  THEN
                      VC = 1;  # REININALIZE VALUE-COUNT               #
                  IF RANGSPEC # HAS BEEN SET AS "TRUE" #  THEN
#***#                   GOTO BOTTOMTR;
                  IF NOT RANGSPEC  THEN 
#***#                   GOTO TOPTR; 
                  END 
              END 
  
          IF TOKENTYPE EQ TYP"LP"  THEN 
              BEGIN 
              PARORD = PARORD + 1;
#***#         GOTO TOPTR; 
              END 
  
          IF TOKENTYPE EQ TYP"COMMA"  THEN
              BEGIN 
              IF PARORD EQ 0  THEN
#***#             GOTO BOTTOMTR;
              IF PARORD EQ 1  THEN
                  BEGIN 
                  SC = SC + 1;
                  IF SC GR VALSETNUM  THEN
#***#                 GOTO BOTTOMTR;
#***#             GOTO TOPTR; 
                  END 
              IF PARORD EQ 2  AND  SC EQ VALSETNUM  THEN
                  BEGIN 
                  VC = VC + 1;
                  IF VC GR VALNUM  # & SC GR VALNUM #  THEN 
#***#                 GOTO BOTTOMTR;
#***#             GOTO TOPTR; 
                  END 
              IF PARORD EQ 2  AND  SC NQ VALSETNUM  THEN
#***#             GOTO TOPTR; 
              END 
  
          IF TOKENTYPE EQ TYP"EQUALS"  OR  TOKENTYPE EQ TYP"DOT"
                 THEN  # DON'T FLAG ERROR HERE, IT HAS BEEN DONE       #
#***#         GOTO TOPTR; 
  
          $BEGIN
          IF TOKENTYPE EQ TYP"EOS" OR TOKENTYPE EQ TYP"ILLEGAL" 
                    THEN
              S$ABORT("CLP$TR-4");
          $END
  
BOTTOMTR: 
#***#     RETURN; 
          END # OF CLP$TR # 
          TERM
  
