*DECK VALTEXT 
USETEXT COMCBEG 
USETEXT COMCCAE 
USETEXT COMQCAF 
USETEXT COMQDEF 
USETEXT COMQFIL 
USETEXT COMQNET 
      FUNC VALTEXT( (TXTADR), (TXTLEN), (FLAG) ) B; 
      BEGIN    # VALTEXT #
# 
**    VALTEXT    VALIDATE ROUTING TEXT. 
* 
*     VALTEXT VALIDATES THE ROUTING TEXT AND MOVES ROUTE PARAMETERS TO
*     THE ACTIVE FILE TABLE ENTRY.
* 
*     FUNC VALTEXT( (TXTADR), (TXTLEN), (FLAG) ) B
* 
*     ENTRY      FILETAB = ACTIVE FILE TABLE ENTRY. 
*                TXTADR = POINTER TO FIRST WORD OF ROUTING TEXT.
*                TXTLEN = LENGTH OF ROUTING TEXT IN CHARACTERS. 
*                FLAG = ROUTING TEXT TYPE:  
*                         'E' = EXPLICIT TEXT,
*                         'I' = IMPLICIT TEXT,
*                         'S' = SYSTEM TEXT.
* 
*     EXIT       VALTEXT = FALSE, IF VALID TEXT STRING. 
*                AFT ENTRY UPDATED. 
* 
*     PROCESS    ADD TERMINATOR (.) TO TEXT STRING. 
*                CALL CHKCMM TO GET CM BUFFER FOR PARAMETERS. 
*                CALL CKCRD TO SEPARATE PARAMETERS
*                IF EXPLICIT TEXT AND VERB NOT "ROUTE": 
*                  RETURN (ERROR).
*                IF IMPLICIT TEXT AND TYPE NOT NS2/NBE: 
*                  RETURN (NO ERROR). 
*                IF SYSTEM TEXT AND TYPE NOT "CYB": 
*                  RETURN (NO ERROR). 
*                IF PARAMETER IS NULL OR
*                  (1ST PARAMETER AND NOT KEYWORD FORM):  
*                  SKIP PARAMETER.
*                AS LONG AS NO ERROR AND MORE PARAMETERS: 
*                  FETCH NEXT PARAMETER (VALUE),
*                  IF INVALID KEYWORD OR VALUE: 
*                    ERROR = TRUE.
*                  ELSE:  
*                    MOVE VALUE TO AFT ENTRY. 
# 
  
# 
****  FORMAL PARAMETERS.
# 
      ITEM TXTADR     U;           # FWA OF ROUTING TEXT #
      ITEM TXTLEN     U;           # LENGTH OF TEXT IN CHARACTERS # 
      ITEM FLAG       C(1);        # "E", "I", OR "S" # 
# 
****  XREF
# 
      XREF
        BEGIN 
        FUNC CHKCMM;
        PROC CKCRD; 
        FUNC CCOUNT     U;         # LENGTH OF CHARACTER ITEM # 
        FUNC FREECMM; 
        FUNC GETLIDA    U;         # GET LID ATTRIBUTES # 
        FUNC GETPIO     U;         # GET PRINT-IMAGE ORDINAL #
        PROC NAME;                 # DEBUG CODE # 
        PROC RMTLOG;               # LOG MESSAGE FOR REMOTE HOST #
        FUNC VALFN      C(10);     # VALIDATE FILE NAME # 
        FUNC XDTB       C(10);     # DELETE TRAILING BLANKS # 
        FUNC XDXB       B;         # CONVERT DEC/OCT TO BINARY #
        END 
# 
****  XREF END
# 
  
      ITEM CHSAVE     B;           # SAVE CHARGE/PROJECT #
      ITEM DCTYPE     C(1);        # DISPOSITION CODE TYPE #
      ITEM ECSAVE     I;           # *EC* VALUE # 
      ITEM ECTYPE     C(1);        # *EC* TYPE #
      ITEM ERR        B;           # TRUE IF ERROR #
      ITEM FWA        U;
      ITEM I          I;
      ITEM ICSAVE     I;           # *IC* VALUE # 
      ITEM J          I;
      ITEM K          I;
      ITEM KEYERR     B;           # KEYWORD ERROR #
      ITEM NOPR       I;           # NUMBER OF PARAMETERS # 
      ITEM PIDX       U;           # PARMETER INDEX # 
      ITEM RKWORD     I;           # KEYWORD ORDINAL #
      ITEM RTVALID    U;           # TYPE OF ROUTING TEXT # 
      ITEM SEPNEQ     B;           # TRUE IF SEPARATOR NOT *=* #
      DEF LEMSGVAL   #34#;
      ARRAY EMSGVAL    S(4);
        BEGIN 
        ITEM EMSGVALTXT C(00,00,LEMSGVAL) = 
                 ["INCORRECT VALUE (1234567=1234567)."];
        END 
  
      DEF LEMSGFNR   #29#;
      ITEM EMSGFNR    C(LEMSGFNR) = "FIRST KEYWORD IS NOT *ROUTE*.";
  
      DEF LEMSGECM   #33#;
      ITEM EMSGECM    C(LEMSGECM) = "INCORRECT EC FOR THIS QUEUE TYPE.";
  
      DEF LEMSGPIM   #37#;
      ITEM EMSGPIM    C(LEMSGPIM) = 
                     "UNKNOWN *PI* PARAMETER, DEFAULT USED."; 
  
      DEF KW$NONE    #O"0"#;       # KEYWORD NOT VALID #
      DEF KW$ERT     #O"1"#;       # KEYWORD VALID ON EXPLICIT TEXT # 
      DEF KW$IRT     #O"2"#;       # KEYWORD VALID ON IMPLICIT TEXT # 
      DEF KW$SRT     #O"4"#;       # KEYWORD VALID ON SYSTEM TEXT # 
      DEF KW$ERTIRT  #O"3"#;       # KEYWORD VALID ON ERT AND IRT # 
      DEF KW$ERTSRT  #O"5"#;       # KEYWORD VALID ON ERT AND SRT # 
      DEF KW$IRTSRT  #O"6"#;       # KEYWORD VALID ON IRT AND SRT # 
      DEF KW$ANY     #O"7"#;       # KEYWORD VALID ON ANY # 
      STATUS ST$RVT                # KEYWORD VALUE TYPES #
                  C2               # TWO CHARACTERS # 
                 ,C3               # THREE CHARACTERS # 
                 ,DEC              # DECIMAL NUMBER # 
                 ,FM               # NOS FAMILY NAME #
                 ,OCT              # OCTAL NUMBER # 
                 ,UJN              # USER JOB NAME #
                 ,UN               # NOS USER NAME #
                 ,A;               # OTHER #
  
      SWITCH SW$RVT:ST$RVT
                  RW$C2 :C2 
                 ,RW$C3 :C3 
                 ,RW$DEC:DEC
                 ,RW$FM :FM 
                 ,RW$OCT:OCT
                 ,RW$UJN:UJN
                 ,RW$UN :UN 
                 ,RW$A  :A; 
  
      STATUS ST$RKW                # KEYWORDS # 
                  NULL
                 ,CFM,CH1,CH2,CUN,DAY 
                 ,DC ,DO
                 ,EC ,FC ,FID,FM ,IC
                 ,ID ,OFM,OT ,OUN,PI
                 ,PJ1,PJ2,PJ3,PJ4 
                 ,PRI,PW1,PW2,REP,SC
                 ,SCL,TID,UJN,UN
                 ,UNKNOWN;
  
      SWITCH SW$RKW:ST$RKW
                  SW$NULL:NULL
                 ,SW$CFM:CFM,SW$CH1:CH1,SW$CH2:CH2,SW$CUN:CUN,SW$DAY:DAY
                 ,SW$DC :DC ,SW$DO :DO
                 ,SW$EC :EC ,SW$FC :FC,SW$FID:FID,SW$FM :FM ,SW$IC :IC
                 ,SW$ID :ID ,SW$OFM:OFM,SW$OT :OT ,SW$OUN:OUN,SW$PI :PI 
                 ,SW$PJ1:PJ1,SW$PJ2:PJ2,SW$PJ3:PJ3,SW$PJ4:PJ4 
                 ,SW$PRI:PRI,SW$PW1:PW1,SW$PW2:PW2,SW$REP:REP,SW$SC :SC 
                 ,SW$SCL:SCL,SW$TID:TID,SW$UJN:UJN,SW$UN :UN
                 ,SW$UNKNOWN:UNKNOWN; 
  
      ARRAY [0:ST$RKW"UNKNOWN"]  S(1);  # TEXT KEYWORDS # 
        BEGIN 
        ITEM RKW         C(00,00,07) =
                 [ " "
                 , "CFM", "CH1", "CH2", "CUN", "DAY"
                 , "DC" , "DO"
                 , "EC" , "FC" , "FID", "FM" , "IC" 
                 , "ID" , "OFM", "OT" , "OUN", "PI" 
                 , "PJ1", "PJ2", "PJ3", "PJ4" 
                 , "PRI", "PW1", "PW2", "REP", "SC" 
                 , "SCL", "TID", "UJN", "UN"
                 , 0 ]; 
        ITEM RKW$EQREQ   B(00,42,01) =
                 [ FALSE
                 , TRUE , TRUE , TRUE , TRUE , TRUE 
                 , TRUE , TRUE
                 , TRUE , TRUE , TRUE , TRUE , TRUE 
                 , TRUE , TRUE , TRUE , TRUE , TRUE 
                 , TRUE , TRUE , TRUE , TRUE
                 , TRUE , TRUE , TRUE , TRUE , TRUE 
                 , TRUE , FALSE, TRUE , TRUE
                 , FALSE ]; 
  
      CONTROL IFEQ OS$NOS;
        ITEM RKW$VALID   U(00,45,03) =
                 [ KW$ANY 
                 ,KW$IRTSRT,KW$IRTSRT,KW$IRTSRT,KW$IRTSRT,KW$ERTSRT 
                 ,KW$ERTSRT,KW$ERTSRT 
                 ,KW$ERTSRT,KW$ERTSRT,KW$ERTSRT,KW$ANY   ,KW$ERTSRT 
                 ,KW$ANY   ,KW$IRTSRT,KW$IRTSRT,KW$IRTSRT,KW$ERTSRT 
                 ,KW$IRTSRT,KW$IRTSRT,KW$IRTSRT,KW$IRTSRT 
                 ,KW$IRTSRT,KW$SRT   ,KW$SRT   ,KW$ERTSRT,KW$ERTSRT 
                 ,KW$ANY   ,KW$ANY   ,KW$ERTSRT,KW$ANY
                 ,KW$IRTSRT]; 
      CONTROL ENDIF;
  
      CONTROL IFEQ OS$NOSBE;
        ITEM RKW$VALID   U(00,45,03) =
                 [ KW$ANY 
                 ,KW$SRT   ,KW$SRT   ,KW$SRT   ,KW$SRT   ,KW$ERTSRT 
                 ,KW$ERTSRT,KW$ERTSRT 
                 ,KW$ERTSRT,KW$ERTSRT,KW$ERTSRT,KW$ERTSRT,KW$ERTSRT 
                 ,KW$SRT   ,KW$SRT   ,KW$SRT   ,KW$SRT
                 ,KW$ERTSRT,KW$SRT   ,KW$SRT   ,KW$SRT   ,KW$SRT
                 ,KW$IRTSRT,KW$SRT   ,KW$SRT   ,KW$ERTSRT,KW$ERTSRT 
                 ,KW$SRT   ,KW$ANY   ,KW$ERTSRT,KW$ERTSRT 
                 ,KW$IRTSRT]; 
      CONTROL ENDIF;
  
        ITEM RKW$RVT     S:ST$RVT(00,48,06) = 
                 [ S"A" 
                 ,S"FM" ,S"FM" ,S"FM" ,S"UN" ,S"DEC"
                 ,S"C2" ,S"C3"
                 ,S"A"  ,S"C2" ,S"UJN",S"FM" ,S"A"
                 ,S"OCT",S"FM" ,S"OCT",S"UN" ,S"FM" 
                 ,S"FM" ,S"FM" ,S"FM" ,S"FM"
                 ,S"OCT",S"DEC",S"DEC",S"DEC",S"OCT"
                 ,S"C2" ,S"A"  ,S"UJN",S"UN"
                 ,S"A" ]; 
  
        ITEM RKW$SW      S:ST$RKW(00,54,06) = 
                 [ S"NULL"
                 ,S"CFM",S"CH1",S"CH2",S"CUN",S"DAY"
                 ,S"DC" ,S"DO"
                 ,S"EC" ,S"FC" ,S"FID",S"FM" ,S"IC" 
                 ,S"ID" ,S"OFM",S"OT" ,S"OUN",S"PI" 
                 ,S"PJ1",S"PJ2",S"PJ3",S"PJ4" 
                 ,S"PRI",S"PW1",S"PW2",S"REP",S"SC" 
                 ,S"SCL",S"TID",S"UJN",S"UN"
                 ,S"UNKNOWN" ]; 
        END 
  
      BASED ARRAY RTEXT  [0:101]  S(1); 
        BEGIN 
        ITEM CHAR       C(0,0,10);  # ROUTING TEXT BUFFER # 
        END 
  
      BASED ARRAY RCRD  [0:101] S(1);  # CRACKED TEXT BUFFER #
        BEGIN 
        ITEM NOP        I(00,00,60);  # NUMBER OF PARAMETERS #
        ITEM PAR        C(00,00,07);  # PARAMETER # 
        ITEM PAR1       C(00,00,01);  # PARAMETER (1ST CHAR) #
        ITEM PAR2       C(00,06,01);  # PARAMETER (2ND CHAR) #
        ITEM PAR3       C(00,12,01);  # PARAMETER (3RD CHAR) #
        ITEM PAR3T7     C(00,12,05);  # PARAMETER (CHAR 3-7) #
        ITEM PAR4T7     C(00,18,04);  # PARAMETER (CHAR 4-7) #
        ITEM SEP        C(00,54,01);  # SEPARATOR # 
        END 
  
      ARRAY [0:0] S(1); 
        BEGIN 
        ITEM VALUEC     C(00,00,10);  # CHARACTER # 
        ITEM VALUEZ     C(00,00,10);  # ZERO-FILLED # 
        ITEM VALUED     U(00,00,60);  # DECIMAL # 
        ITEM VALUEO     U(00,00,60);  # OCTAL # 
        END 
  
        $BEGIN
        NAME("VALTEXT");           # DEBUG CODE # 
        $END
  
      DCTYPE = "  ";               # NO *DC* SPECIFIED YET #
      ECSAVE = -1;                 # NO *EC* VALUE #
      ICSAVE = -1;                 # NO *IC* VALUE #
      IF FLAG EQ "I"
      THEN
        BEGIN 
        RTVALID = KW$IRT; 
        CHSAVE = TRUE;
        END 
  
      ELSE
        BEGIN 
        CHSAVE = FALSE; 
        IF FLAG EQ "S"
        THEN
          BEGIN 
          RTVALID = KW$SRT; 
          CHSAVE = FILECHGU EQ 0; 
          END 
  
        ELSE
          BEGIN 
          RTVALID = KW$ERT; 
          END 
  
        END 
  
      P<RTEXT> = TXTADR;           # SET TEXT ADDR #
      IF (TXTLEN LT 0)
        OR (TXTLEN GT 256)
      THEN
        BEGIN 
        TXTLEN = 256;              # MAX CHAR LENGTH #
        END 
  
      J = TXTLEN; 
      K = J/10;                    # WORD # 
      J = J - (K*10);              # LAST CHAR POSITION + 1 # 
      C<J,1>CHAR[K] = ".";         # TERMINATE TEXT # 
      FWA = CHKCMM(0, 256);        # GET CMM BUFFER FOR CRACKED PARAMS #
      CKCRD(TXTADR, FWA);          # CRACK ROUTING TEXT # 
      P<RCRD> = FWA;               # SET BUFFER ADDR (CRACKED PARAMS) # 
      NOPR = NOP[0];               # NUMBER OF PARAMETERS # 
      IF (NOPR LT 1)
        OR ( (RTVALID NE KW$SRT)
             AND (PAR[1] NE "ROUTE") )
      THEN
        BEGIN 
        FWA = FREECMM(FWA); 
        RMTLOG(LOC(EMSGFNR), LEMSGFNR); 
        VALTEXT = TRUE;            # ERROR IN TEXT #
        RETURN; 
        END 
  
      IF (SEP[2] NE "=")           # IF FIRST PARAM UNEQUIVALENCED #
      THEN
        BEGIN 
        PIDX = 3 - 1;              # ASSUME *LFN* AND IGNORE #
        END 
  
      ELSE
        BEGIN 
        PIDX = 2 - 1; 
        END 
  
      ASLONGAS (PIDX LT NOPR)      # WHILE MORE PARAMETERS #
      DO
        BEGIN 
        PIDX = PIDX + 1;
        SEPNEQ = SEP[PIDX] NE "="; # TRUE IF SEPARATOR NOT = #
        RKW[ST$RKW"UNKNOWN"] = PAR[PIDX]; 
        RKWORD = 0; 
        ASLONGAS RKW[ST$RKW"UNKNOWN"] NE RKW[RKWORD]
        DO
          BEGIN 
          RKWORD = RKWORD + 1;
          END 
  
        IF (RKW$VALID[RKWORD] LAN RTVALID) EQ 0 
        THEN
          BEGIN 
          KEYERR = TRUE;           # KEYWORD INVALID FOR THIS TYPE #
          EXIT LOOP;
          END 
  
        ERR = FALSE;
        KEYERR = FALSE; 
        IF SEPNEQ                  # IF PARAMETER NOT FOLLOWED BY *=* # 
        THEN
          BEGIN 
          IF RKW$EQREQ[RKWORD]     # IF *=* REQUIRED #
          THEN
            BEGIN 
            KEYERR = TRUE;
            EXIT LOOP;
            END 
  
          END 
  
        ELSE
          BEGIN 
          IF PIDX LT NOPR 
          THEN
            BEGIN 
            PIDX = PIDX + 1;       # POINT TO VALUE # 
            ERR = SEP[PIDX] EQ "="; 
            END 
  
          ELSE                     # *KW=.* # 
            BEGIN 
            PAR[PIDX] = " ";       # ASSUME NULL VALUE #
            END 
  
          END 
  
        GOTO SW$RVT[RKW$RVT[RKWORD]];  # SIMULATED CASE STATEMENT # 
  
RW$C2:  
          VALUEC = PAR[PIDX]; 
          IF (   (PAR1[PIDX] LT "A")
              OR (PAR1[PIDX] GT "9")
              OR (PAR2[PIDX] LT "A")
              OR (PAR2[PIDX] GT "9")
              OR (PAR3T7[PIDX] NE "     ") )
          THEN
            BEGIN 
            IF (VALUEC NE "C")
              OR (RKW$SW[RKWORD] NE ST$RKW"TID")
            THEN
              BEGIN 
              ERR = TRUE; 
              END 
  
            END 
  
          GOTO RW$RVTEND; 
  
RW$C3:  
          VALUEC = PAR[PIDX]; 
          IF (   (PAR1[PIDX] LT "A")
              OR (PAR1[PIDX] GT "9")
              OR (PAR2[PIDX] LT "A")
              OR (PAR2[PIDX] GT "9")
              OR (PAR3[PIDX] LT "A")
              OR (PAR3[PIDX] GT "9")
              OR (PAR4T7[PIDX] NE "     ") )
          THEN
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO RW$RVTEND; 
  
RW$DEC: 
          ERR = XDXB(PAR[PIDX], 1, J);
          VALUED = J; 
          GOTO RW$RVTEND; 
  
RW$FM:  
RW$UN:  
          VALUEZ = XDTB(PAR[PIDX]); 
          GOTO RW$RVTEND; 
  
RW$OCT: 
          ERR = XDXB(PAR[PIDX], 0, J);
          VALUEO = J; 
          GOTO RW$RVTEND; 
  
RW$UJN: 
          VALUEZ = VALFN(PAR[PIDX]);
          GOTO RW$RVTEND; 
  
RW$A: 
          VALUEC = PAR[PIDX]; 
          GOTO RW$RVTEND; 
  
RW$RVTEND:                         # END OF CASE #
        IF ERR
        THEN
          BEGIN 
          EXIT LOOP;
          END 
  
        GOTO SW$RKW[RKW$SW[RKWORD]];  # SIMULATED CASE STATEMENT #
  
SW$CFM: 
        CONTROL IFEQ OS$NOS;
          IF FILECFM EQ 0          # IF NO CREATION FAMILY YET #
          THEN
            BEGIN 
            FILECFMC = VALUEZ;
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$CH1: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILECHG1C = VALUEZ;    # SAVE CHARGE NUMBER (1-7) # 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$CH2: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILECHG2C = VALUEZ;    # SAVE CHARGE NUMBER (8-10) #
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$CUN: 
        CONTROL IFEQ OS$NOS;
          IF FILECUN EQ 0          # IF NO CREATION USER YET #
          THEN
            BEGIN 
            FILECUNC = VALUEZ;     # SAVE CREATION USER NUMBER #
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$DAY: 
          FILEDAYF = TRUE;
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$DC:  
          DC$DC[MAXDCV] = VALUEC; 
          J = 0;
          ASLONGAS DC$DC[MAXDCV] NE DC$DC[J]
          DO
            BEGIN 
            J = J + 1;
            END 
  
          IF DC$DSPDC[J] NE "  "
          THEN
            BEGIN 
            FILEDCC = DC$DSPDC[J];
            DCTYPE = DC$TYPE[J];
            IF (ECSAVE LT 0)       # IF NO *EC* SPECIFIED YET # 
            THEN
              BEGIN 
              ECSAVE = DC$DEFEC[J] - O"33"; 
              ECTYPE = DCTYPE;     # USE DEFAULT *EC* # 
              END 
  
            OD$TYPE[MAXODV]  = DCTYPE;
            OD$DEFEC[MAXODV] = DC$DEFEC[J]; 
            J = 0;
            ASLONGAS  OD$TYPE[J]  NE OD$TYPE[MAXODV]
              OR (   (OD$DEFEC[J] NE " ") 
                  AND(OD$DEFEC[J] NE OD$DEFEC[MAXODV])) 
            DO
              BEGIN 
              J = J+1;
              END 
  
            FILEOTY = OD$OD[J];    # OUTPUT DISPOSITION CODE #
            FILEICS = 0;           # CLEAR EC AND IC #
            FILEECS = 0;           # BECAUSE DC SPECIFIED # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$DO:  
          GLA$RETURN = GETLIDA(VALUEC); 
          IF GLA$ATTRIB NE 0       # IF LID EXISTS #
          THEN
            BEGIN 
            FILESLDC = VALUEC;
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$EC:  
          EC$EC[MAXECV] = VALUEC; 
          J = 0;
          ASLONGAS EC$EC[MAXECV] NE EC$EC[J]
          DO
            BEGIN 
            J = J + 1;
            END 
  
          IF EC$DSPEC[J] NE " " 
          THEN
            BEGIN 
            ECSAVE = EC$DSPEC[J] - O"33"; 
            ECTYPE = EC$TYPE[J];
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$FC:  
          FILEPFC = VALUEC;        # SAVE FORMS CODE #
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$FID: 
SW$UJN: 
          FILEJBN = VALUEZ;        # SAVE FID/UJN # 
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$FM:  
          FILEDFMC = VALUEZ;
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$IC:  
          IC$IC[MAXICV] = VALUEC; 
          J = 0;
          ASLONGAS IC$IC[MAXICV] NE IC$IC[J]
          DO
            BEGIN 
            J = J + 1;
            END 
  
          IF IC$DSPIC[J] NE " " 
          THEN
            BEGIN 
            ICSAVE = IC$DSPIC[J] - O"33"; 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$ID:  
          IF (VALUEO GE 0)
            AND (VALUEO LE O"77") 
          THEN
            BEGIN 
            FILEID = VALUEO;       # SAVE VALUE # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$OFM: 
        CONTROL IFEQ OS$NOS;
          IF FILEOFM EQ 0          # IF NO OWNER FAMILY YET # 
          THEN
            BEGIN 
            FILEOFMC = VALUEZ;
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$OUN: 
        CONTROL IFEQ OS$NOS;
          IF (FILEOUN EQ 0)        # IF NO OWNER UN EXISTS #
          THEN
            BEGIN 
            FILEOUNC = VALUEZ;
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$OT:  
        CONTROL IFEQ OS$NOS;
          IF (VALUEO GE 0)
            AND (VALUEO LE 7) 
          THEN
            BEGIN 
            FILEORG = VALUEO;      # SAVE VALUE # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PI:  
        CONTROL IFEQ OS$NOS;
          FILEPI = GETPIO(VALUEZ);  # GET PRINT-IMAGE ORDINAL # 
          IF FILEPI EQ 0           # IF UNDEFINED # 
          THEN
            BEGIN 
            RMTLOG(LOC(EMSGPIM), LEMSGPIM); 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PJ1: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILEPJ11C = VALUEZ;    # SAVE PROJECT NUMBER (1-7) #
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PJ2: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILEPJ12C = VALUEZ;    # SAVE PROJECT NUMBER (8-10) # 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PJ3: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILEPJ21C = VALUEZ;    # SAVE PROJECT NUMBER (11-17) #
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PJ4: 
        CONTROL IFEQ OS$NOS;
          IF CHSAVE                # IF SAVING CHARGE/PROJECT # 
          THEN
            BEGIN 
            FILEPJ22C = VALUEZ;    # SAVE PROJECT NUMBER (18-20) #
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PRI: 
        CONTROL IFEQ OS$NOSBE;
          IF (VALUEO GE 0)
            AND (VALUEO LE O"7777") 
          THEN
            BEGIN 
            FILEPRI = VALUEO;      # SAVE VALUE # 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PW1: 
        CONTROL IFEQ OS$NOS;
          IF (VALUED GE 0)
            AND (VALUED LE O"77777777777777") 
          THEN
            BEGIN 
            FILEPW1 = VALUED;      # SAVE VALUE # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$PW2: 
        CONTROL IFEQ OS$NOS;
          IF (VALUED GE 0)
            AND (VALUED LE O"77777777777777") 
          THEN
            BEGIN 
            FILEPW2 = VALUED;      # SAVE VALUE # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$REP: 
          IF VALUED GT 31          # IF VALUE IS TOO LARGE #
          THEN
            BEGIN 
            VALUED = 31;           # CLEAR COUNT #
            END 
  
          FILEREP = VALUED;        # SAVE VALUE # 
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$SC:  
          IF (VALUEO GE 0)
            AND (VALUEO LE O"77") 
          THEN
            BEGIN 
            FILESPC = VALUEO;      # SAVE VALUE # 
            END 
  
          ELSE
            BEGIN 
            ERR = TRUE; 
            END 
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$SCL: 
        CONTROL IFEQ OS$NOS;
          FILESCL = VALUEC;        # SAVE SERVICE CLASS # 
        CONTROL ENDIF;
  
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$TID: 
          FILETIDC = VALUEC;       # SAVE TERMINAL ID # 
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$UN:  
          FILEDUNC = VALUEZ;       # DESTINATION USER # 
          GOTO SW$RKWEND;          # END OF CASE #
  
SW$NULL:  
SW$UNKNOWN: 
SW$RKWEND:                         # END OF CASE #
        IF ERR
          OR KEYERR 
        THEN
          BEGIN 
          EXIT LOOP;
          END 
  
        END LOOP:                  # END OF ASLONGAS #
  
      IF ERR
        OR KEYERR 
      THEN
        BEGIN 
        C<17,7>EMSGVALTXT = RKW[RKWORD];
        J = 17 + CCOUNT(RKW[RKWORD]); 
        IF (NOT KEYERR)            # IF NOT KEYWORD ERROR # 
          AND (NOT SEPNEQ)         #   AND KEYWORD EQUIVALENCED # 
        THEN
          BEGIN 
          C<J,1>EMSGVALTXT = "="; 
          J = J + 1;
          C<J,7>EMSGVALTXT = PAR[PIDX]; 
          J = J + CCOUNT(PAR[PIDX]);
          END 
  
        C<J,2>EMSGVALTXT = ").";
        J = J + 2;
        RMTLOG(LOC(EMSGVAL), J);
        ERR = TRUE; 
        END 
  
      IF (NOT ERR)                 # IF NO ERROR #
        AND (ECSAVE GE 0)          #   AND *EC* SPECIFIED # 
      THEN
        BEGIN 
        IF DCTYPE EQ " "           # IF NO *DC* SPECIFIED # 
        THEN
          BEGIN 
          DC$DC[MAXDCV] = FILEOTY; # DETERMINE TYPE OF PREVIOUS DC #
          J = 0;
          ASLONGAS DC$DC[MAXDCV] NE DC$DC[J]
          DO
            BEGIN 
            J = J + 1;
            END 
  
          DCTYPE = DC$TYPE[J];
          END 
  
        IF DCTYPE NE ECTYPE        # ERROR IF *DC*/*EC* MISMATCH #
        THEN
          BEGIN 
          ERR = TRUE; 
          RMTLOG(LOC(EMSGECM), LEMSGECM); 
          END 
  
        END 
  
      IF (NOT ERR)                 # IF NO ERROR #
      THEN
        BEGIN 
        IF (FILETIDC EQ "C")       # IF ROUTE TO CENTRAL SITE # 
        THEN
          BEGIN 
          FILETID = 0;             # CLEAR TERMINAL ID #
          FILEDUN = 0;             # CLEAR DESTINATION UN # 
          FILEDFM = 0;             # CLEAR DESTINATION FM # 
          END 
  
        IF (ICSAVE LT 0)           # IF IC= UNSPECIFIED  #
          AND (   (DCTYPE EQ "P"   # AND ASCII PRINT     #
                   AND ECSAVE EQ 6) 
               OR (DCTYPE EQ "S"   #        OR PLOT FILE #
                   AND ECSAVE EQ 2))
        THEN
          BEGIN 
          ICSAVE = 1;              # SET IC = ASCII # 
          END 
  
        IF (ICSAVE GE 0)           # IF IC SPECIFIED #
        THEN
          BEGIN 
          FILEICS = ICSAVE;        # SAVE IC #
          END 
  
        IF (ECSAVE GE 0)           # IF EC SPECIFIED #
        THEN
          BEGIN 
          FILEECS = ECSAVE;        # SAVE EC #
          END 
  
        END 
  
      FWA = FREECMM(FWA);          # RELEASE BUFFER # 
      VALTEXT = ERR;
  
      END      # VALTEXT #
    TERM
