*DECK S$CKSPC 
  
          PROC S$CKSPC(STRING$,COL$,TOKEN$,STATUS$);
  
#**       CKSPC - CHECK TOKENS SURROUNDING A SPACE TOKEN               #
#                                                                      #
#       GIVEN -                                                        #
#         COL$ = ARRAY CONTAINING CURRENT AND PREVIOUS COLUMN NO.S     #
#         STATUS$ = ERROR STATUS                                       #
#         STRING$ = ARRAY CONTAINING STRING LENGTH AND CONTENTS        #
#         TOKEN$ = ARRAY WITH TOKEN CONTENTS AND TYPE                  #
#       DOES -                                                         #
#           GIVEN THE CURRENT TOKEN AS A SPACE, THIS PROC CHECKS       #
#         THE PREVIOUS AND THE NEXT TOKENS SURROUNDING THIS SPACE.     #
#           AFTER IT DETERMINES THAT THERE IS NO ERROR(GIVEN THE       #
#         PREVIOUS TOKEN THAT THE CURRENT SPACE IS ALLOWABLE) THE      #
#         PROC THEN EITHER LEAVES THE TOKEN TYPE = "SPACE" OR IT       #
#         SETS TOKENTYPE  = "COMMA" IF THE SPACE IS TO BE CONSIDERED   #
#         A DELIMITER.                                                 #
#                                                                      #
  
          BEGIN 
  
*CALL A 
  
*CALL CLPTYPE 
  
*CALL STATUS$ 
  
*CALL CLPARRA 
  
*CALL STRING$ 
  
          ARRAY  NXT$[0:0]  S(2);                # NEXT TOKEN          #
              BEGIN 
              ITEM NXT$CVAL  C(0,0,11);          # CHAR. VALUE         #
              ITEM NXT$T     S:TYP(1,6,27);      # TYPE                #
              ITEM NXT$PT    S:TYP(1,33,27);     # PREVIOUS TYPE       #
              END 
  
          DEF   NXT$TYPE   # NXT$T[0]#; 
  
          ARRAY KOL$[0:0] S(1); 
              BEGIN 
              ITEM    KOL$CURRENT  I(0,0,30); 
              ITEM    KOL$PREVIOUS I(0,30,30);
              END 
          DEF KOL   # KOL$CURRENT[0]#;
  
          XREF
              BEGIN 
              PROC S$GTTOK; 
              PROC S$ABORT; 
              END 
  
  
          KOL = COL;  # USED INSTEAD OF "COL" SO "COL" IS NOT ADVANCED #
          KOL$PREVIOUS[0] = COL;
          NXT$TYPE = TYP"NONE"; 
          NXT$PT[0] = TYP"NONE";
  
          S$GTTOK(STRING$,KOL$,NXT$,STATUS$); 
  
          IF TOKENPRVT EQ  TYP"RP"
                     OR 
             TOKENPRVT EQ  TYP"NAME"
                     OR 
             TOKENPRVT EQ  TYP"NUM" 
                     OR 
             TOKENPRVT EQ  TYP"$NAM"
                     OR 
             TOKENPRVT EQ  TYP"STRING"  THEN
              IF NXT$TYPE EQ TYP"LP"
                         OR 
                 NXT$TYPE EQ TYP"$NAM"
                         OR 
                 NXT$TYPE EQ TYP"NAME"
                         OR 
                 NXT$TYPE EQ TYP"NUM" 
                         OR 
                 NXT$TYPE EQ TYP"STRING"  THEN
                      #    SET TOKENTYPE TO "COMMA"(INSTEAD OF SPACE)  #
                      #    AND TREAT THIS SPACE AS A DELIMITER         #
                  TOKENTYPE  = TYP"COMMA";
          END # S$CKSPC # 
          TERM
