*DECK S$CKPRV 
  
          PROC S$CKPRV(STRING$,COL$,TOKEN$,STATUS$);
  
#**       S$CKPRV - CHECK PREVIOUS TOKEN TYPE                          #
#                                                                      #
#       CALLING SEQUENCE -                                             #
#       GIVEN -                                                        #
#         STATUS$ = ERROR STATUS(EXPANDED INTO AN ARRAY)               #
#         COL$ = COLUMN POSITION OF TOKEN                              #
#         STRING$ = STRING CONTIANING TEXT                             #
#         TOKEN$ = ARRAY CONTAINING CURRENT AND PREVIOUS TOKEN TYPES   #
#       DOES -                                                         #
#           DETERMINE IF THE CURRENT TOKEN SYNTACTICALLY CLASHES       #
#         WITH THE PREVIOUS TOKEN_TYPE.  IF IT FINDS A SYNTAX ERROR,   #
#         AN ERROR IS ISSUED, OTHERWISE CONTROL IS RETURNED.           #
#                                                                      #
          BEGIN 
  
*CALL A 
  
*CALL E$
  
*CALL STRING$ 
  
*CALL CLPTYPE 
  
*CALL CLPARRA 
  
*CALL STATUS$ 
  
*CALL DEBUG 
  
          XREF
              BEGIN 
              PROC S$ABORT; 
              PROC S$ERROR; 
              PROC S$PRTCD; 
              END 
  
          $BEGIN
#           THIS PROC SHOULD NOT BE CALLED FOR CERTAIN PRVT            #
          IF TOKENPRVT EQ  TYP"DOLLAR" OR TOKENPRVT EQ  TYP"SPACE"
                OR TOKENPRVT EQ TYP"EOS"  THEN
                  S$ABORT("S$CKPRV-2"); 
          $END
  
#           WHEN TOKENTYPE  IS ONE OF THE BELOW, THERE IS AN ERROR     #
  
          IF TOKENPRVT EQ TYP"DOT"  OR TOKENPRVT EQ TYP"ILLEGAL" THEN 
              BEGIN 
              $BEGIN
#??#          S$PRTCD("DOTILLEGAL GIVEN TO CKPRV"); 
              FLUSH;
              $END
#***#         RETURN; 
              END 
  
          IF TOKENTYPE EQ  TYP"SPACE" THEN
#***#         RETURN;  # ANY PRVT IS GOOD EXCEPT THOSE ABOVE           #
  
          IF TOKENTYPE EQ TYP"RP" THEN
              BEGIN 
              IF TOKENPRVT EQ  TYP"LP" THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$9,STRING$,PTR);  # ( ) MUST ENCLOSE        #
#                    A VALUE                                           #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ  TYP"NONE" OR TOKENPRVT EQ  TYP"COMMA"
                  THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$14,STRING$,PTR);  # THIS CHARACTER         #
#                    , MUST BE A LETTER,DIGIT ( " SPACE OR ,           #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ  TYP"EQUALS" THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$10,STRING$,PTR); # CHARACTER AFTER A =     #
#                    MUST BE A LETTER,DIGIT ( $ " OR SPACE             #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ  TYP"ELLIPSIS" THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$19,STRING$,PTR);  # THE HIGH AND LOW       #
#                    VALUES OF A RANGE MUST BE A INTEGER,              #
#                    R1,R2 OR R3                                       #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE # IF NONE OF THE ABOVE PRVT HOLD THEN               #
#***#             RETURN; 
              END # OF TYP = "RP"      #
  
          ELSE
          IF TOKENTYPE EQ  TYP"LP"  OR  TOKENTYPE EQ  TYP"NUM"  OR
                TOKENTYPE EQ  TYP"NAME"  OR TOKENTYPE EQ  TYP"$NAM"  OR 
                TOKENTYPE EQ  TYP"STRING"    THEN 
              BEGIN 
              IF TOKENPRVT EQ  TYP"RP"  OR TOKENPRVT EQ  TYP"NUM"  OR 
                    TOKENPRVT EQ  TYP"NAME"  OR TOKENPRVT EQ  TYP"$NAM" 
                    OR  TOKENPRVT EQ  TYP"STRING"    THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$1,STRING$,PTR);  # A SPACE OR , EXPECTED   #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ TYP"ELLIPSIS"  AND
                 (TOKENTYPE EQ TYP"LP" AND
                 TOKENTYPE EQ TYP"$NAM" ) 
                      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; 
#***#             RETURN; 
                  END 
              ELSE # IF PRVT IS ANYOTHER TYPE THEN                     #
#***#             RETURN; 
              END # OF TOKENTYPE  = RP, NUM,..STRING #
  
          ELSE
          IF TOKENTYPE EQ TYP"DOT"  THEN
#***#         RETURN;      # ISSUE ERROR FROM CLP$SPL                  #
  
          ELSE  # IF TOKENTYPE IS ',' '=' '..' OR 'EOS'                #
              BEGIN 
              IF TOKENPRVT EQ TYP"RP"  AND
                    (TOKENTYPE EQ TYP"EQUALS"  OR 
                     TOKENTYPE EQ TYP"ELLIPSIS")
                     THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$17,STRING$,PTR);  # CHARACTER AFTER ) MUST #
#                    BE , ) OR SPACE                                   #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF (TOKENPRVT EQ TYP"$NAM"
                 AND  (TOKENTYPE EQ TYP"EQUALS"  OR 
                       TOKENTYPE EQ TYP"ELLIPSIS")) 
                             THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$35,STRING$,PTR);  # ONLY A , ) .. OR       #
#                     SPACE CAN FOLLOW A PARAMETER VALUE               #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ TYP"LP"  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$18,STRING$,PTR);  # CHARACTER AFTER (      #
#                    MUST BE A LETTER,DIGIT $ " ( OR SPACE             #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ TYP"ELLIPSIS"  THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$19,STRING$,PTR);   # THE HIGH AND          #
#                    LOW VALUES OF THIS RANGE MUST BE AN               #
#                    INTEGER,STRING,R1,R2 OR R3                        #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ  TYP"NUM"  AND  TOKENTYPE EQ  TYP"EQUALS" 
                       THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$21,STRING$,PTR);  # CHARACTER FOLLOWING    #
#                    AN INTEGER MUST BE ) , .. OR SPACE                #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF TOKENPRVT EQ TYP"STRING" 
                        AND TOKENTYPE EQ TYP"EQUALS"
                      THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$35,STRING$,PTR);  # ONLY A , ) .. OR       #
#                    SPACE CAN FOLLOW A PARAMETER VALUE                #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF (TOKENPRVT EQ  TYP"NONE")  AND  (TOKENTYPE EQ
                    TYP"EQUALS"  OR  TOKENTYPE EQ  TYP"ELLIPSIS"  OR
                    TOKENTYPE EQ  TYP"EOS" )     THEN 
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$14,STRING$,PTR);  # THIS CHARACTER         #
#                    MUST BE A LETTER,DIGIT ( " SPACE OR ,             #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE
              IF (TOKENPRVT EQ  TYP"COMMA")  AND
                  (TOKENTYPE EQ  TYP"EQUALS"  OR
                   TOKENTYPE EQ  TYP"ELLIPSIS"  OR
                   TOKENTYPE EQ  TYP"EOS")
                        THEN
                  BEGIN 
                  PTR = PREVCOL;
                  S$ERROR(E$14,STRING$,PTR);  # THIS CHARACTER         #
#                    , MUST BE A LETTER,DIGIT ( " SPACE OR ,           #
                  STATUS$NORML = FALSE; 
#***#             RETURN; 
                  END 
              ELSE # FOR ANY OTHER PRVT/TYPE COMBINATION               #
#***#             RETURN; 
              END 
          END # OF S$CKPRVT # 
  
          TERM
