*DECK,CRACKER 
USETEXT CYBRDEF 
USETEXT MISC$ 
USETEXT ERR$COM 
USETEXT CMD$COM 
      PROC CRACKER;          # PARSE AN INPUT COMMAND LINE AND SET     #
*IF DEF,IMS 
 #
*1DC  CRACKER 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        CRACKER             A. M. PRATT         77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE PARSES AN INPUT COMMAND LINE IN ORDER TO BE ABLE
*        TO SET FLAGS AND VALUE CELLS IN THE COMMAND INTERFACE TABLE
*        IN ACCORDANCE WITH THE CONTENTS OF THAT LINE.  CIT THEN BECOMES
*        THE BASIS FOR COMMAND PROCESSOR OPERATION. 
* 
*     3. METHOD USED
*        RBF COMMANDS HAVE THE FOLLOWING FORM - COMMAND NAME (OR ABBRE- 
*        VIATED COMMAND NAME), FOLLOWED BY ZERO OR MORE PARAMETER 
*        "PHRASES". FOR EXAMPLE, IF A USER WANTS TO CHANGE THE PRIORITY 
*        OF A PARTICULAR JOB (AASIEXE) TO 7123 (OCTAL) AND HAVE THE 
*        FILE REPEATED ONCE (THAT IS, THE FILE WILL ACTUALLY BE 
*        PRINTED TWICE) HE MAY DO SO BY ENTERING "CHANGE AASIEXE, 
*        PRI = 7123, REP".  ALL THREE ALLOWABLE COMMAND PHRASES ARE 
*        INCLUDED HERE 1) PARAMETER-NAME = VALUE (PRI = 7760),
*        2) VALUE ONLY (AASIEXE) AND 3) PARAMETER-NAME ONLY (REP).
*        WHEN A PARAMETER-NAME-ONLY PHRASE IS ACCEPTABLE, CRACKER 
*        SUPPLIES A DEFAULT VALUE - IN THIS CASE "REP" IMPLIES "REP=1". 
*        EACH PHRASE IS TERMINATED BY A BLANK OR A COMMA. EXTRA 
*        BLANKS MAY BE INSERTED FOR READABILITY ANYWHERE EXCEPT IN THE
*        MIDST OF A PARAMETER-NAME OR A VALUE.  IN ORDER TO ALLOW 
*        CRACKER TO PARSE A NEW COMMAND CORRECTLY, ENTRIES MUST 
*        BE MADE IN THE COMMAND-NAME TABLE(CNTTAB). IF PARAMETER-NAMES
*        OR KEYWORDS ARE INVOLVED THAT HAVE NOT BEEN INTRODUCED BY
*        PREVIOUS COMMANDS, THEN CHANGES MUST BE MADE IN THE PARAMETER
*        NAME TABLE (PNTTAB), OR THE VALUE NAME TABLE(VNTTAB), RESPEC-
*        TIVELY, AND ANOTHER ENTRY MADE IN THE STATUS LIST -ENTITIES-.
*        IN ADDITION, FOR EACH ENTRY IN VNTTAB THERE MUST BE A CORRES-
*        PONDING ENTRY IN THE STATUS LIST -VNTORD-. SEE COMMENTS ASSOCI-
*        ATED WITH EACH TABLE.
* 
*        THE GENERAL FLOW IS AS FOLLOWS - CNAME IS CALLED TO PICK UP
*        THE COMMAND NAME AND LOOK IT UP IN CNTTAB. ENTITIES (I.E.
*        PARAMETER-NAMES,VALUES,OR DELIMITERS) ARE PICKED UP BY GETATOM.
*        DEPENDING ON WHAT IT FINDS, GETDEL (FOR DELIMITERS), GETFC 
*        (FOR FORMS CODE), GETINT (FOR INTEGER), OR GETNAME IS CALLED 
*        TO GET THE ENTITY. IN PHRASES WITH A PARAMETER-NAME AND A VALUE
*        THE VALUE-TYPE IS DETERMINED BY WHAT IS APPROPRIATE FOR THAT 
*        PARAMETER NAME ( FOR EXAMPLE "PRI = " MUST BE FOLLOWED ONLY BY 
*        AN OCTAL INTEGER). IN PHRASES WITH ONLY A VALUE, NAMES ARE 
*        ASSUMED TO BE JOB NAMES IF 7-CHAR LONG AND OTHERWISE MUST BE 
*        VALUE NAMES (KEYWORDS) AND SEARCHED FOR IN VNTTAB.  AN INTEGER 
*        VALUE MUST BE DECIMAL SINCE IT CAN ONLY OCCUR (ALONE) ON THE 
*        SKIP COMMAND. WHEN THE END OF A PHRASE IS REACHED (THAT IS, THE
*        DELIMITER AFTER THE VALUE HAS BEEN FOUND) THEN, IN THE CASE
*        OF A VALUE-ONLY PHRASE, THE ROUTINE "VAL" IS CALLED, OTHERWISE,
*        THE ROUTINE "EVAL" IS CALLED. THE PARAMETER NAME, IF PRESENT,
*        AND/OR THE VALUE, IF PRESENT, ARE CHECKED FOR APPROPRIATENESS
*        TO THE COMMAND.  IF ALL GOES WELL THEN A FLAG AND/OR VALUE 
*        IS SET IN CIT$TABLE, IF NOT AND THERE ARE ALTERNATE CNTTAB 
*        ENTRIES FOR THE SAME COMMAND, THE WHOLE PROCESS IS RESTARTED 
*        WITH THE NEXT CNTTAB ENTRY.  IF THE SET OF PHRASES ASSOCIATED
*        WITH THE COMMAND DO NOT MATCH ANY CNTTAB ENTRY, THEN A DIAGNOS-
*        TIC AND A COMMAND TYPE S"NOCOMMAND" IS PLACED IN CIT$TABLE,
*        OTHERWISE CIT$TABLE WILL CONTAIN THE STATUS VALUE OF THE 
*        COMMAND AND THE COMBINATION OF VALUES AND FLAGS WHICH REPRESENT
*        AN ENCODING OF THE COMMAND WHICH WILL BE PASSED BACK TO "CMD"
*        FOR EXECUTION. 
* 
* 
*     4. ENTRY PARAMETERS 
*        CIT$TABLE - THE COMMAND INTERFACE TABLE
* 
*     5. EXIT PARAMETERS
*        CIT$TABLE - THE COMMAND INTERFACE TABLE
* 
*     6. COMDECKS CALLED
*        CMD$COM
* 
*     7. ROUTINES CALLED
*        ERRPRO              BUILDS ERROR MESSAGE 
*        EVAL1               HANDLE CASE -PARAMETER-NAME,-
*        EVAL2               HANDLE CASE -PARAMETER-NAME=VALUE,-
*        FINDBIT             KEYWORD LEGALITY SEARCH
*        GETATOM             FETCHES ONE LEXICAL ATOM 
*        GETCNAME            SCAN FOR COMMAND NAME
*        VAL                 HANDLE CASE -VALUE ONLY,-
*        CLEANUP             CLEANUP PROCESSING AFTER PARSE COMPLETE
*        SUPBLKS             SUPPRESS BLANKS IN FAMILY/USER NAMES 
* 
*     8. CONSOLE MESSAGES 
*        A. ILLEGAL SYNTAX
 #
*ENDIF
      CONTROL EJECT;
      BEGIN                  # BEGIN MAIN SECTION OF CRACKER           #
  
  
  
  
# MAINTYPE, BELOW, GIVES THE MAJOR TYPES OF LEXICAL ATOMS (SCAN TOKENS)#
# SUBTYPE IS A LIST NAMING SUBTYPES OF VALUE ATOMS #
  
      STATUS MAINTYPE 
          NULL,              # NO TYPE #
          PNAME,             # PARAMETER NAME # 
          EQUALSP,           # EQUAL SEPARATOR #
          VALUE,             # VALUE #
          COMMASP;           # SEPARATOR #
  
  
      STATUS SUBTYPE NULL,VNAME,USRNAME,FAMNAME,
                     JOBNAME, 
                     FMSCODE, 
                     OCTAL, 
                     DECIMAL, 
                     ADECIMAL,
                     TRTYPE,
                     CLASS, 
                     LASTSUB; 
  
  
# THE STATUS LIST, ENTITIES, ASSIGNS VALUES WHICH REPRESENT KEYWORDS   #
# MOST OF THEM REPRESENT RBF KEYWORDS AND NEED NO EXPLANATION, A FEW,  #
# HOWEVER, HAVE SPECIAL MEANING, AND ARE DEFINED AS FOLLOWS -          #
# ALLD    STANDS FOR ALL REMOTE BATCH DEVICES (CRA,LPA,PLA)            #
# ALLOD   STANDS FOR ALL RBF OUTPUT DEVICES (CPA,LPA,PLA)              #
# ALLQ    STANDS FOR ALL RBF QUEUES (IN,EX,PR,PU,PT)                   #
# ALLOQ   STANDS FOR RBF OUTPUT QUEUES (PR,PU,PT)                      #
# FVAL    STANDS FOR A FAMILY NAME (VALUE)                             #
# JVAL    STANDS FOR A JOB NAME (VALUE)                                #
# OVAL    STANDS FOR AN OCTAL INTEGER (VALUE)                          #
# UVAL    STANDS FOR A USER NAME (VALUE)                               #
# EPKEY   MEANS THIS KEYWORD IS A PARAMETER-NAME (NOT A VALUE)         #
# USED    MEANS THIS KEYWORD HAS BEEN SET IN THIS COMMAND              #
# GROUP   MEANS THAT AT LEAST ONE OF THE PARAMS WITH THIS FLAG IS REQ"D#
# MULTI   MEANS THAT THIS PARAMETER MAY HAVE MORE THAN ONE VALUE AT A  #
# TIME                                                                 #
  
      STATUS ENTITIES 
        NULL,CR,LP,CP,PL, 
        IN,PR,PU,PT,EX,DEV, 
        ACK,BAN,FMT,DFL,END,EXT,HST,RFR,
        ALLD,ALLOD,ALLQ,ALLOQ,
        WID,FAM,FC,JOB,PRI,REP,USR, 
        BLK,TR,SC,
        FVAL,JVAL,OVAL,UVAL,VALUE,
        EPKEY,USED,GROUP,MULTI; 
  
  
  
  
# CTY, BELOW, GIVES THE TYPES OF DISPLAY CODE CHARACTERS #
  
      STATUS CTY
        NULL, 
        LETTER,              # DENOTED BY -A- BELOW # 
        DIGIT,               # DENOTED BY -B- BELOW # 
        DELIM,               # DENOTED BY -C- BELOW # 
        SPECIAL,             # DENOTED BY -D- BELOW # 
        SIGN;                # DENOTED BY -E- BELOW # 
  
  
# BELOW, EACH DISPLAY CODE CHARACTER IS TYPED # 
  
      ITEM CT  C(64) =
      "DAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBEEDDDDDCCCDDDDDDDDDDDDDDDDD"
      ; 
  
      ITEM TYPETR C (10) = "A6B6A9T6T8";
  
# CRACKER DEFS #
  
      DEF CONTINUE     #1#;  # MOVE-ON TO NEXT STATE #
      DEF ERROR        #2#;  # CREATIVE SYNTAX #
      DEF SKIP         #3#;  # SKIP STATES #
      DEF EVAL1        #4#;  # EVALUATE TYPE-1 COMMAND PHRASE # 
      DEF EVAL2        #5#;  # EVALUATE TYPE-2 COMMAND PHRASE # 
      DEF EVAL3        #6#;  # EVALUATE TYPE-3 COMMAND PHRASE # 
      DEF SETMODE      #7#;  # SET REQUIRED-MODE CELLS                 #
      DEF ENDCM        #8#;  # END OF COMMAND                          #
      DEF NVNTS        #26#; # NR OF ENTERED IN VNTTAB #
      DEF NPNTS        #9#;  # NR ENTRIES IN PNTTAB                    #
      DEF NCNTS        #35#; # NR ENTRIES IN CNTTAB                    #
      DEF NVNTM        #25#; # NVNTS - 1 #
      DEF NPNTM        #9#; 
      DEF NERRS        #15#; # NR OF ENTRIES IN ERRTAB                 #
      DEF NUMPDT       #37#; # PARAMETER DESCRIPTOR TABLE ENTRIES      #
      DEF PNTJOBORD    #3#;  # ORDINAL OF "JOB" IN PNTTAB - CHANGE IT  #
                             # IF POSITION IN PNTTAB OF "JOB" CHANGES  #
      DEF INCLUDE      #1#;  # PRESET INDICATING SET MEMBERSHIP        #
  
# THESE STATUS VALUES ARE USED TO LINK KEYWORD ENTITIES WITH THEIR     #
# ORDINALS IN VNTTAB.  THEY MUST BE KEPT IN PRECISELY THE SAME ORDER   #
# AS VNTTAB ENTRIES.                                                   #
  
      STATUS VNTORD 
        NULL, 
        CR, 
        CRA,
        LP, 
        LPA,
        CP, 
        CPA,
        PL, 
        PLA,
        EX, 
        IN, 
        PR, 
        PU, 
        PT, 
        DEV,
        ACK,
        BAN,
        FMT,
        DFL,
        END,
        EXT,
        HST,
        RFR,
        ALLD, 
        ALLOD,
        ALLQ, 
        ALLOQ;
  
  
# CRACKER VARIABLES                                                    #
  
      COMMON VCOM;
      BEGIN 
      ITEM I            I;   # CHARACTER POSITION OF SCANNER           #
      ITEM RTYPE       I;    # REQUIRED ATOM TYPE # 
      ITEM MTYPE       I;    # ACTUAL ATOM (MAIN) TYPE #
      ITEM RSTYPE      I;    # REQUIRED VALUE SUBTYPE # 
      ITEM STYPE       I;    # ACTUAL VALUE SUBTYPE # 
      ITEM CTYPE       I;    # CHARACTER TYPE # 
      ITEM VALUE       I;    # INTEGER VALUE TAKEN FROM COMMAND LINE #
      ITEM SCVALUE     C(2); # SERVICE CLASS VALUE FROM COMMAND LINE #
      ITEM NAME        C(10);# PARAMETER/VALUE/COMMAND/FAMILY/USER   #
      ITEM LENGTH      I;    # LENGTH OF NAME IN CHARACTERS # 
      ITEM CHAR        C(1); # CURRENT SCAN CHARACTER # 
      ITEM EOLFLAG     B;    # SET AT END-OF-LINE # 
      ITEM DELCHAR     C(1); # CURRENT DELIMITER (CHARACTER) #
      ITEM EFLAG       B;    # ERROR FLAG TEMPORARY # 
      ITEM MINUSFLAG   B;    # SET IF MINUS JUST ENCOUNTERED #
      ITEM CNTX        I;    # CNTTAB ORDINAL # 
      ITEM PNTX        I;    # PNTTAB ORDINAL # 
      ITEM VNTX        I;    # VNTTAB ORDINAL # 
      ITEM NSTATE      I;    # CURRENT STATE OF CRACKER # 
      ITEM ACTION      I;    # ROUTINE TO CALL ACCORDING TO STATE-TABLE#
      ITEM J           I;    # TEMPORARY #
      ITEM K           I;    # TEMPORARY #
      ITEM BASE        I;    # TEN IF DECIMAL, EIGHT IF OCTAL # 
      ITEM NPARS       I;    # NUMBER OF PARAMETERS WITH THIS COMMAND # 
      ITEM IRUN        I;    # CONTROL VARIABLE # 
      ITEM NCHARS      I;    # NUMBER OF CHARACTERS IN COMMAND LINE # 
      ITEM TEMPLATE    I;    # TEMPORARY #
      ITEM DEVO        I;    # DEVICE ORDINAL TEMPORARY # 
      ITEM ISAVE       I;    # SAVES SCAN POINTER # 
      ITEM SKIPSTATE   I;    # USED TO SKIP OVER CERTAIN CRACKER STATES#
      ITEM GROUPFLAG   B;    # SET IF SUBSET OF PARAMS FORM A GROUP    #
      ITEM GROUPUSED   B;    # SET IF AT LEAST ONE GROUP-PARAM IS USED #
      ITEM GETATOMK    I;    # TEMPORARY #
      ITEM EVALK  I;
      ITEM GETCNAMEJ  I;
      ITEM GETCNAMEK  I;
      ITEM GETDELK  I;
      ITEM GETINTK  I;
      ITEM GETNAMEK  I; 
      ITEM SEARCHK  I;
      ITEM VALJ  I; 
      ITEM VALK  I; 
      ITEM LASTI I;          # HOLDS SCAN POINTER AT START OF TOKEN    #
      ITEM CNAME C(10);      # NAME OF CURRENT COMMAND #
      ITEM ERRNR S:ERRLIST;  # STATUS VALUE OF ERROR FOR ERRPRO # 
      ITEM DUM1 I;
      ITEM DUM2 I;
      ITEM DUM3 I;
      ITEM IPARS  I;         # CONTROL VARIABLE IN CRACKER MAIN BODY   #
      ITEM GO$ON  B;         # TEMPORARY USED BY GETDEL                #
      ITEM BINVAL  I;        # TEMPORARY USED BY GETINT                #
      ITEM MAIN        I;    # CONTROL VARIABLE ON MAIN FOR-LOOP       #
      ITEM FATALFLAG   B;    # FOR ERRORS THAT MIGHT BE FATAL/NON-FATAL#
      ITEM MISPARFLAG B;     # TRUE IF FOR ONE PRODUCTION, ERRNR=MISPAR#
      END                    # END OF VCOM                             #
  
  
# THE FOLLOWING TABLE PROVIDES STORAGE FOR PARAMETER #
# DESCRIPTORS ASSOCIATED WITH ONE COMMAND # 
  
      COMMON PDTCOM;
      BEGIN 
  
      ARRAY PDESCS[1:7] P(1); 
        BEGIN 
        ITEM XVBITS   I(0,0,42);   # BIT MAP #
        ITEM XMODE     U(0,42,4);  # MODE OF DEFAULT VALUE             #
        ITEM XDEFAULT  I(0,46,14); # DEFAULT VALUE                     #
        ITEM XPDT     I(0,0,WL);   # WHOLE WORD # 
        END 
      END                    # END OF PDTCOM #
  
  
# THE FOLLOWING TABLE DIRECTS CRACKER TO ACTIVATE ROUTINE R # 
# WHEN IN STATE S AND TOKEN T IS RECEIVED FROM THE SCANNER #
  
      ARRAY [1:5] P(1); 
        BEGIN 
        ITEM XPNAME    I(0,0,6) =[CONTINUE,ERROR,ERROR,ERROR,ERROR];
        ITEM XEQUALS   I(0,6,6) =[ERROR,SETMODE,ERROR,ERROR,ERROR]; 
        ITEM XVALUE    I(0,12,6)=[SKIP,ERROR,CONTINUE,ERROR,ERROR]; 
        ITEM XCOMMASP  I(0,18,6)=[ENDCM,EVAL1,ERROR,EVAL2,EVAL3]; 
        ITEM XSTATE    I(0,0,WL);  # ONE COMPLETE STATE                #
        END 
  
  
# COMMAND NAME TABLE - CONTAINS COMMAND-ORIENTED INFORMATION #
  
      ARRAY CNTTAB[1:NCNTS] P(2); 
        BEGIN 
        ITEM NAMEA C(0,0,8) = [ 
          "ABORT",
          "CANCEL", 
          "CHANGE", 
          "CHANGE", 
          "DISPLAY",
          "DIVERT", 
          "DIVERT", 
          "DIVERT", 
          "DIVERT", 
          "END",
          "GO", 
          "IAF",
          "LOGIN",
          "LOGON",
          "LOGOUT", 
          "LOGOFF", 
          "PURGE",
          "PURGE",
          "RESTORE",
          "RESTORE",
          "RESTORE",
          "RESTORE",
          "RESTORE",
          "RESUME", 
          "RETURN", 
          "REWIND", 
          "SET",
          "SET",
          "SKIP", 
          "STOP", 
          "SUPPRESS", 
          "SUPPRESS", 
          "SUPPRESS", 
          "SUPPRESS", 
          "SUPPRESS"];
  
  
# THIS ITEM GIVES THE INDEX OF THE -ALL- VALUE NAME APPROPRIATE # 
# TO THE PARTICULAR COMMAND # 
  
      ITEM ALLX S:VNTORD(0,48,6) =
      [ S"ALLD ",            # ABT                                     #
        S"ALLOQ",            # CAN                                     #
        S"ALLOQ",            # CHG                                     #
                ,            # CHG                                     #
                ,            # DIS                                     #
        S"ALLOQ",            # DIV                                     #
        S"ALLOQ",            # DIV                                     #
        S"ALLQ ",            # DIV                                     #
        S"ALLQ ",            # DIV                                     #
                ,            # END                                     #
        S"ALLD ",            # GO                                      #
                ,            # IAF                                     #
                ,            # LOGIN                                   #
                ,            # LOGON                                   #
                ,            # LOGOUT                                  #
                ,            # LOGOFF                                  #
        S"ALLQ ",            # PUR                                     #
        S"ALLQ ",            # PUR                                     #
                ,            # RES                                     #
                ,            # RES                                     #
                ,            # RES                                     #
                ,            # RES                                     #
                ,            # RES                                     #
                ,            # R                                       #
        S"ALLOD",            # RET                                     #
        S"ALLOD",            # REW                                     #
                ,            # SET                                     #
                ,            # SET                                     #
                ,            # SKP                                     #
        S"ALLD ",            # S                                       #
                ,            # SUP                                     #
                ,            # SUP                                     #
                ,            # SUP                                     #
                ,            # SUP                                     #
                ];           # SUP                                     #
  
  
# THIS ITEM GIVES THE COMMAND NUMBER TO PASS ON # 
# TO THE COMMAND PROCESSOR #
  
      ITEM CMDT S:IACOMMAND(0,54,6) = 
        [ S"ABORT", 
          S"CANCEL",
          S"CHANGE",
          S"CHANGE",
          S"DISPLAY", 
          S"DIVERT",
          S"DIVERT",
          S"DIVERT",
          S"DIVERT",
          S"END", 
          S"GO",
          S"IAF", 
          S"LOGIN", 
          S"LOGIN", 
          S"LOGOUT",
          S"LOGOUT",
          S"PURGE", 
          S"PURGE", 
          S"RESTORE", 
          S"RESTORE", 
          S"RESTORE", 
          S"RESTORE", 
          S"RESTORE", 
          S"RESUME",
          S"RETURN",
          S"REWIND",
          S"SET", 
          S"SET", 
          S"SKIP",
          S"STOP",
          S"SUPPRESS",
          S"SUPPRESS",
          S"SUPPRESS",
          S"SUPPRESS",
          S"SUPPRESS"]; 
  
  
# THIS ITEM GIVES ABBREVIATIONS FOR THE COMMAND NAMES # 
  
      ITEM NAMEB C(1,0,3) = 
        [ "ABT",
          "CAN",
          "CHG",
          "CHG",
          "DIS",
          "DIV",
          "DIV",
          "DIV",
          "DIV",
          "END",
          "G",
          "IAF",
          "...",             # LOGIN #
          "...",             # LOGON #
          "...",             # LOGOUT#
          "...",             # LOGOFF#
          "PUR",
          "PUR",
          "RES",
          "RES",
          "RES",
          "RES",
          "RES",
          "R",
          "RET",
          "REW",
          "SET",
          "SET",
          "SKP",
          "S",
          "SUP",
          "SUP",
          "SUP",
          "SUP",
          "SUP"]; 
  
  
# THE FOLLOWING ITEM GIVES INDICES TO THE VARIOUS # 
# PARAMETER DESCRIPTORS REQUIRED BY EACH COMMAND #
  
      ITEM PDI   I(1,18,42) = 
        [ O"01000000000000", # ABT                                     #
          O"02000000000000", # CAN                                     #
          O"03040506000000", # CHG                                     #
          O"03450000000000", # CHG                                     #
          O"07100000000000", # DIS                                     #
          O"14113700000000", # DIV                                     #
          O"14111213000000", # DIV                                     #
          O"15163700000000", # DIV                                     #
          O"15161213000000", # DIV                                     #
          O"00000000000000", # END                                     #
          O"01000000000000", # G                                       #
          O"00000000000000", # IAF                                     #
          O"00000000000000", # LOGIN                                   #
          O"00000000000000", # LOGON                                   #
          O"00000000000000", # LOGOUT                                  #
          O"00000000000000", # LOGOFF                                  #
          O"03160000000000", # PUR                                     #
          O"15360000000000", # PUR                                     #
          O"23240000000000", # RES                                     #
          O"40410000000000", # RES                                     #
          O"22200000000000", # RES                                     #
          O"42430000000000", # RES                                     #
          O"33430000000000", # RES                                     #
          O"00000000000000", # R                                       #
          O"25260000000000", # RET                                     #
          O"25000000000000", # REW                                     #
          O"21223031324400", # SET                                     #
          O"21273031440000", # SET                                     #
          O"33340000000000", # SKP                                     #
          O"01350000000000", # S                                       #
          O"23240000000000", # SUP                                     #
          O"40410000000000", # SUP                                     #
          O"22200000000000", # SUP                                     #
          O"42430000000000", # SUP                                     #
          O"33430000000000"];# SUP                                     #
  
        END                  # END OF CNTTAB #
  
  
  
  
# THE VARIABLE NAME TABLE GIVES ALL INFORMATION PERTINENT TO #
# THE KEYWORDS WHICH STAND FOR DEVICES,QUEUES,VALUES,ETC, SUCH #
# AS CR,EX,FMT,ALL,ETC #
  
      ARRAY VNTTAB[1:NVNTS] P(1); 
        BEGIN                # BEGIN VNTTAB                            #
        ITEM VNAME C(0,0,3) = 
          [ "CR", 
            "CRA",
            "LP", 
            "LPA",
            "CP", 
            "CPA",
            "PL", 
            "PLA",
            "EX", 
            "IN", 
            "PR", 
            "PU", 
            "PT", 
            "DEV",
            "ACK",
            "BAN",
            "FMT",
            "DFL",
            "END",
            "EXT",
            "HST",
            "RFR",
            "=ALLD",
            "=ALLOD", 
            "=ALLQ",
            "=ALLOQ"];
  
  
# THE FOLLOWING ITEM GIVES THE BIT POSITION WITHIN #
# THE FLAG WORD IN CIT$TABLE FOR EACH VALUE NAME #
  
      ITEM VFB U(0,18,6) =
        [ 0,                 # CR # 
          0,                 # CRA# 
          0,                 # LP # 
          0,                 # LPA# 
          0,                 # CP # 
          0,                 # CPA# 
          0,                 # PL # 
          0,                 # PLA# 
          31,                # EX # 
          32,                # IN # 
          30,                # PR # 
          29,                # PU # 
          28,                # PT # 
          24,                # DEV #
          37,                # ACK #
          36,                # BAN #
          35,                # FMT #
          34,                # DFL #
          33,                # END #
          39,                # EXT #
          42,                # HST #
          40,                # RFR #
          0,                 # ALLD # 
          0,                 # ALLOD #
          25,                # ALLQ # 
          26 ];              # ALLOQ #
  
  
# THIS ITEM GIVES VALUES TO BE PLACES IN OUTPUT CELLS # 
# WHEN THE CORRESPONDING KEYWORD IS ENCOUNTERED # 
  
      ITEM VOVAL  I(0,24,6) = 
        [ 1,                 # CR # 
          1,                 # CRA# 
          2,                 # LP # 
          2,                 # LPA# 
          3,                 # CP # 
          3,                 # CPA# 
          4,                 # PL # 
          4,                 # PLA# 
          0,                 # EX # 
          0,                 # IN # 
          0,                 # PR # 
          0,                 # PU # 
          0,                 # PT # 
          0,                 # DEV #
          0,                 # ACK #
          0,                 # BAN #
          0,                 # FMT #
          0,                 # DFL #
          0,                 # END #
          0,                 # EXT #
          0,                 # HST #
          0,                 # RFR #
          0,                 # ALLD # 
          5,                 # ALLOD #
          0,                 # ALLQ # 
          0 ];               # ALLOQ #
  
  
# THE FOLLOWING ITEM GIVES VALUES USED TO REPRESENT THE KEYWORD # 
  
      ITEM VLVAL U(0,30,6) =
        [ ENTITIES"CR", 
          ENTITIES"CR", 
          ENTITIES"LP", 
          ENTITIES"LP", 
          ENTITIES"CP", 
          ENTITIES"CP", 
          ENTITIES"PL", 
          ENTITIES"PL", 
          ENTITIES"EX", 
          ENTITIES"IN", 
          ENTITIES"PR", 
          ENTITIES"PU", 
          ENTITIES"PT", 
          ENTITIES"DEV",
          ENTITIES"ACK",
          ENTITIES"BAN",
          ENTITIES"FMT",
          ENTITIES"DFL",
          ENTITIES"END",
          ENTITIES"EXT",
          ENTITIES"HST",
          ENTITIES"RFR ", 
          ENTITIES"ALLD", 
          ENTITIES"ALLOD",
          ENTITIES"ALLQ", 
          ENTITIES"ALLOQ"]; 
  
  
# THIS ITEM YIELDS -TRUE- IF AND ONLY IF THE #
# CORRESPONDING KEYWORD REPRESENTS A DEVICE # 
  
      ITEM VDFLG  B(0,36,1) = 
        [ TRUE,              # CR  #
          TRUE,              # CRA #
          TRUE,              # LP  #
          TRUE,              # LPA #
          TRUE,              # CP  #
          TRUE,              # CPA #
          TRUE,              # PL  #
          TRUE,              # PLA #
          FALSE,             # EX  #
          FALSE,             # IN  #
          FALSE,             # PR  #
          FALSE,             # PU  #
          FALSE,             # PT  #
          FALSE,             # DEV #
          FALSE,             # ACK #
          FALSE,             # BAN #
          FALSE,             # FMT #
          FALSE,             # DFL #
          FALSE,             # END #
          FALSE,             # EXT #
          FALSE,             # HST #
          FALSE,             # RFR #
          TRUE,              # ALLD # 
          TRUE,              # ALLOD #
          FALSE,             # ALLQ # 
          FALSE ];           # ALLOQ #
  
  
# THIS ITEM IS TRUE ONLY WHEN THE CORRESPONDING KEYWORD                #
# REPRESENTS ALL DEVICES OF A GIVEN TYPE - CRA,LPA,ETC                 #
  
        ITEM VDAFLG  B(0,37,1) =
          [ FALSE,           # CR  #
            TRUE,            # CRA #
            FALSE,           # LP  #
            TRUE,            # LPA #
            FALSE,           # CP  #
            TRUE,            # CPA #
            FALSE,           # PL  #
            TRUE,            # PLA #
            FALSE,           # EX  #
            FALSE,           # IN  #
            FALSE,           # PR  #
            FALSE,           # PU  #
            FALSE,           # PT  #
            FALSE,           # DEV #
            FALSE,           # ACK #
            FALSE,           # BAN #
            FALSE,           # FMT #
            FALSE,           # DFL #
            FALSE,           # END #
            FALSE,           # EXT #
            FALSE,           # HST #
            FALSE,           # RFR #
          FALSE,             # ALLD # 
          FALSE,             # ALLOD #
          FALSE,             # ALLQ # 
          FALSE ];           # ALLOQ #
  
      END                    # END OF VNTTAB #
  
  
  
  
  
# THE PARAMETER NAME TABLE (PNTTAB) GIVES INFORMATION # 
# RELATED TO KEYWORDS WHICH REPRESENT PARAMETERS #
  
      ARRAY PNTTAB[0:NPNTM];
      BEGIN 
      ITEM PNAME  C(0,0,3) = # PARAMETER NAME # 
        [ "WID",
          "FAM",
          "FC",              # FORMS CODE # 
          "JOB",
          "PRI",
          "REP",
          "USR",             # USR #
          "BLK",             # BLOCK SIZE # 
          "TR",              # TRAIN TYPE # 
          "SC"];             # SERVICE CLASS #
  
  
# THE FOLLOWING ITEM GIVES THE LOWEST VALUE THE PARAMETER MAY ATTAIN #
  
      ITEM LB  U(0,18,15) = 
        [ 50,                # WID #
          0,                 # FAM #
          0,                 # FORMS CODE # 
          0,                 # JOB #
          0,                 # PRI #
          0,                 # REP #
          0,                 # USR #
          200,               # BLOCK SIZE # 
          0,                 # TRAIN TYPE # 
          0];                # SERVICE CLASS #
  
  
# THE FOLLOWING ITEM GIVES THE HIGHEST VALUE THE PARAMETER MAY ATTAIN  #
  
      ITEM UB  U(0,33,15) = 
        [150,                # WID #
           0,                # FAM #
           0,                # FORMS CODE # 
           0,                # JOB #
        4095,                # PRI #
          31,                # REP #
           0,                # USR #
        2043,                # BLK #
           0,                # TR  #
           0];               # SC  #
# THE FOLLOWING ITEM GIVES THE VALUE TYPE REQUIRED BY THE PARAMETER  #
  
      ITEM RSUBTYPE S:SUBTYPE(0,48,6) = 
        [S"DECIMAL",         # WID #
         S"FAMNAME",         # FAM #
         S"FMSCODE",         # FC  #
         S"JOBNAME",         # JOB #
         S"OCTAL",           # PRI #
         S"DECIMAL",         # REP #
         S"USRNAME",         # USR #
         S"ADECIMAL",        # BLK #
         S"TRTYPE",          # TR  #
         S"CLASS"];          # SC  #
  
  
# THE FOLLOWING VALUES ARE USED TO DETERMINE THE LEGALITY OF THE #
# PARAMETER NAMES IN A GIVEN CONTEXT #
  
      ITEM LVAL S:ENTITIES(0,54,6) =
        [ S"WID", 
          S"FAM", 
          S"FC",             # FORMS CODE # 
          S"JOB", 
          S"PRI", 
          S"REP", 
          S"USR", 
          S"BLK",            # BLK #
          S"TR",             # TR  #
          S"SC"];            # SC  #
      END                    # END OF PNTTAB #
  
  
  
  
  
# EACH PARAMETER OF AN RBF COMMAND HAS A WELL-DEFINED SET OF KEYWORDS  #
# OR VALUES ASSOCIATED WITH IT.  FOR EXAMPLE, A CERTAIN COMMAND MAY    #
# HAVE A SINGLE PARAMETER SPECIFYING AN OUTPUT QUEUE.  THIS IS         #
# EQUIVALENT TO DECLARING THAT THE PARAMETER USES PARAMETER DESCRIPTOR #
# SET 2, BELOW, WHICH DECLARES "PR","PU","PT", AND "ALL" TO BE LEGAL   #
# KEYWORDS IN SATISFACTION OF THIS PARAMETER.  "ALL", IN THIS CONTEXT, #
# MEANS "ALL OUTPUT QUEUES"                                            #
      ARRAY PDTSET S(NUMPDT); 
        BEGIN 
  
  
# PARAMETER SET 01B                                                    #
  
        ITEM ENTAB U(00,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAC U(00,ENTITIES"CP   ",1) = [INCLUDE]; 
        ITEM ENTAD U(00,ENTITIES"CR   ",1) = [INCLUDE]; 
        ITEM ENTAE U(00,ENTITIES"LP   ",1) = [INCLUDE]; 
        ITEM ENTAF U(00,ENTITIES"PL   ",1) = [INCLUDE]; 
        ITEM ENTAG U(00,ENTITIES"ALLD ",1) = [INCLUDE]; 
        ITEM MOD01 U(00,42,4)  = [SUBTYPE"VNAME  "];
        ITEM DEF01 I(00,46,14) = [VNTORD"LP "]; 
  
  
# PARAMETER SET 02B                                                    #
  
        ITEM ENTAH U(01,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAI U(01,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTAJ U(01,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM ENTAK U(01,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTEF U(01,ENTITIES"ALLOQ",1) = [INCLUDE]; 
        ITEM MOD02 U(01,42,4)  = [SUBTYPE"VNAME "]; 
        ITEM DEF02 I(01,46,14) = [VNTORD"ALLOQ"]; 
  
  
# PARAMETER SET 03B                                                    #
  
        ITEM ENTAL U(02,ENTITIES"JOB  ",1) = [INCLUDE]; 
        ITEM ENTAM U(02,ENTITIES"JVAL ",1) = [INCLUDE]; 
        ITEM MOD03 U(02,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF03 I(02,46,14) = [VNTORD"NULL "]; 
  
  
# PARAMETER SET 04B                                                    #
  
        ITEM ENTAN U(03,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAO U(03,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTAP U(03,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM ENTAQ U(03,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTAR U(03,ENTITIES"ALLOQ",1) = [INCLUDE]; 
        ITEM MOD04 U(03,42,4)  = [SUBTYPE"VNAME"];
        ITEM DEF04 I(03,46,14) = [VNTORD"PR"];
  
  
# PARAMETER SET 05B                                                    #
  
        ITEM ENTAS U(04,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAT U(04,ENTITIES"PRI  ",1) = [INCLUDE]; 
        ITEM ENTAU U(04,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM ENTDU B(04,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD05 U(04,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF05 I(04,46,14) = [VNTORD"NULL"];
  
  
# PARAMETER SET 06B                                                    #
  
        ITEM ENTAV U(05,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAW U(05,ENTITIES"REP  ",1) = [INCLUDE]; 
        ITEM ENTAX U(05,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM ENTDV B(05,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD06 U(05,42,4)  = [SUBTYPE"DECIMAL"];
        ITEM DEF06 U(05,46,14) = [1]; 
  
  
# PARAMETER SET 07B                                                    #
  
        ITEM ENTAY U(06,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTAZ U(06,ENTITIES"JOB  ",1) = [INCLUDE]; 
        ITEM ENTBA U(06,ENTITIES"JVAL ",1) = [INCLUDE]; 
        ITEM ENTBB U(06,ENTITIES"DEV  ",1) = [INCLUDE]; 
        ITEM ENTBC U(06,ENTITIES"EX   ",1) = [INCLUDE]; 
        ITEM ENTBD U(06,ENTITIES"IN   ",1) = [INCLUDE]; 
        ITEM ENTBE U(06,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTBF U(06,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTBG U(06,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM MOD07 U(06,42,4)  = [SUBTYPE"VNAME"];
        ITEM DEF07 I(06,46,14) = [VNTORD"DEV"]; 
  
  
# PARAMETER SET 10B                                                    #
  
        ITEM ENTBH U(07,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTBI U(07,ENTITIES"RFR  ",1) = [INCLUDE]; 
        ITEM MOD08 U(07,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF08 I(07,46,14) = [VNTORD"NULL "]; 
  
  
# PARAMETER SET 11B                                                    #
  
        ITEM ENTBK U(08,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTBL U(08,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM ENTBM U(08,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTEH U(08,ENTITIES"ALLOQ",1) = [INCLUDE]; 
        ITEM MOD09 U(08,42,4)  = [SUBTYPE"NULL" ];
        ITEM DEF09 I(08,46,14) = [VNTORD"NULL "]; 
  
  
# PARAMETER SET 12B                                                    #
  
        ITEM ENTBN U(09,ENTITIES"USR  ",1) = [INCLUDE]; 
        ITEM ENTEG U(09,ENTITIES"EPKEY",1) = [INCLUDE]; 
        ITEM MOD10 U(09,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF10 U(09,46,14) = [ENTITIES"NULL"];
  
  
# PARAMETER SET 13B                                                    #
  
        ITEM ENTBO U(10,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTBP U(10,ENTITIES"FAM  ",1) = [INCLUDE]; 
        ITEM ENTDW B(10,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD11 U(10,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF11 I(10,46,14) = [VNTORD"NULL"];
  
  
# PARAMETER SET 14B                                                    #
  
        ITEM ENTBQ U(11,ENTITIES"EXT  ",1) = [INCLUDE]; 
        ITEM MOD12 U(11,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF12 I(11,46,14) = [VNTORD"NULL"];
  
  
# PARAMETER SET 15B                                                    #
  
        ITEM ENTBR U(12,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTBS U(12,ENTITIES"JOB  ",1) = [INCLUDE]; 
        ITEM ENTBT U(12,ENTITIES"JVAL ",1) = [INCLUDE]; 
        ITEM MOD13 U(12,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF13 I(12,46,14) = [VNTORD"NULL"];
  
# PARAMETER SET 16B                                                    #
  
        ITEM ENTBU U(13,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTBV U(13,ENTITIES"EX   ",1) = [INCLUDE]; 
        ITEM ENTBW U(13,ENTITIES"IN   ",1) = [INCLUDE]; 
        ITEM ENTBX U(13,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTBY U(13,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM ENTBZ U(13,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTCA U(13,ENTITIES"ALLQ ",1) = [INCLUDE]; 
        ITEM MOD14 U(13,42,4)  = [SUBTYPE"VNAME"];
        ITEM DEF14 I(13,46,14) = [VNTORD"ALLQ"];
  
  
# PARAMETER SET 17B                                                    #
  
        ITEM ENTCB U(14,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM MOD15 U(14,42,4) = [SUBTYPE"NULL"];
        ITEM DEF15 I(14,46,14)= [VNTORD"NULL "];
  
  
# PARAMETER SET 20B                                                    #
  
        ITEM ENTCC U(15,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCD U(15,ENTITIES"FMT  ",1) = [INCLUDE]; 
        ITEM ENTCE U(15,ENTITIES"BAN  ",1) = [INCLUDE]; 
        ITEM ENTCF U(15,ENTITIES"MULTI",1) = [INCLUDE]; 
        ITEM ENTCG U(15,ENTITIES"ACK  ",1) = [INCLUDE]; 
        ITEM MOD16 U(15,42,4) = [SUBTYPE"VNAME"]; 
        ITEM DEF16 I(15,46,14) = [VNTORD"FMT"]; 
  
  
# PARAMETER SET 21B                                                    #
  
        ITEM ENTFA U(16,ENTITIES"NULL",1) = [INCLUDE];
        ITEM ENTFB U(16,ENTITIES"BLK",1) = [INCLUDE]; 
        ITEM ENTFC B(16,ENTITIES"EPKEY",1) = [TRUE];
        ITEM ENTFD U(16,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM MOD17 U(16,42,4) = [SUBTYPE"ADECIMAL"];
        ITEM DEF17 U(16,46,14) = [200]; 
  
  
# PARAMETER SET 22B                                                    #
  
        ITEM ENTCI U(17,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCJ U(17,ENTITIES"LP   ",1) = [INCLUDE]; 
        ITEM MOD18 U(17,42,4) = [SUBTYPE"VNAME "];
        ITEM DEF18 I(17,46,14) = [VNTORD"LP"];
  
  
# PARAMETER SET 23B                                                    #
  
        ITEM ENTCK U(18,ENTITIES"CR   ",1) = [INCLUDE]; 
        ITEM MOD19 U(18,42,4) = [SUBTYPE"NULL "]; 
        ITEM DEF19 I(18,46,14) =  [VNTORD"NULL "];
  
  
# PARAMETER SET 24B                                                    #
  
        ITEM ENTCL U(19,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCM U(19,ENTITIES"ACK  ",1) = [INCLUDE]; 
        ITEM MOD20 U(19,42,4) =  [SUBTYPE"VNAME"];
        ITEM DEF20 I(19,46,14) = [VNTORD"ACK"]; 
  
  
# PARAMETER SET 25B                                                    #
  
        ITEM ENTCN U(20,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCO U(20,ENTITIES"CP   ",1) = [INCLUDE]; 
        ITEM ENTCP U(20,ENTITIES"LP   ",1) = [INCLUDE]; 
        ITEM ENTCQ U(20,ENTITIES"PL   ",1) = [INCLUDE]; 
        ITEM ENTCR U(20,ENTITIES"ALLOD",1) = [INCLUDE]; 
        ITEM MOD21 U(20,42,4) = [SUBTYPE"VNAME"]; 
        ITEM DEF21 I(20,46,14) = [VNTORD"LP"];
  
  
# PARAMETER SET 26B                                                    #
  
        ITEM ENTCS U(21,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCT U(21,ENTITIES"PRI  ",1) = [INCLUDE]; 
        ITEM ENTDX B(21,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD22 U(21,42,4) = [SUBTYPE"OCTAL"]; 
        ITEM DEF22 I(21,46,14) = [O"100"];
  
  
# PARAMETER SET 27B                                                    #
  
        ITEM ENTEI U(22,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTEJ U(22,ENTITIES"LP   ",1) = [INCLUDE]; 
        ITEM ENTCU U(22,ENTITIES"CP   ",1) = [INCLUDE]; 
        ITEM ENTCV U(22,ENTITIES"PL   ",1) = [INCLUDE]; 
        ITEM MOD23 U(22,42,4) = [SUBTYPE"VNAME"]; 
        ITEM DEF23 I(22,46,14) = [VNTORD"LP"];
  
  
# PARAMETER SET 30B                                                    #
  
        ITEM ENTCW U(23,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCX U(23,ENTITIES"REP  ",1) = [INCLUDE]; 
        ITEM ENTEB U(23,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM ENTDY B(23,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD24 U(23,42,4)  = [SUBTYPE"DECIMAL"];
        ITEM DEF24 I(23,46,14) =  [1];
  
  
# PARAMETER SET 31B                                                    #
  
        ITEM ENTCY U(24,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTCZ U(24,ENTITIES"FC   ",1) = [INCLUDE]; 
        ITEM ENTEC U(24,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM ENTDZ B(24,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD25 U(24,42,4)  = [SUBTYPE"FMSCODE"];
        ITEM DEF25 U(24,46,14) =  [0];
  
  
# PARAMETER SET 32B                                                    #
  
        ITEM ENTDA U(25,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTDB U(25,ENTITIES"WID  ",1) = [INCLUDE]; 
        ITEM ENTED U(25,ENTITIES"GROUP",1) = [INCLUDE]; 
        ITEM ENTEA B(25,ENTITIES"EPKEY",1) = [TRUE];
        ITEM MOD26 U(25,42,4)  =  [SUBTYPE"DECIMAL"]; 
        ITEM DEF26 U(25,46,14) =  [151];
  
  
# PARAMETER SET 33B                                                    #
  
        ITEM ENTDC U(26,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTDD U(26,ENTITIES"CP   ",1) = [INCLUDE]; 
        ITEM ENTDE U(26,ENTITIES"LP   ",1) = [INCLUDE]; 
        ITEM ENTDF U(26,ENTITIES"PL   ",1) = [INCLUDE]; 
        ITEM MOD27 U(26,42,4)  =  [SUBTYPE"VNAME "];
        ITEM DEF27 I(26,46,14) =  [VNTORD" LP "]; 
  
  
# PARAMETER SET 34B                                                    #
  
        ITEM ENTDG U(27,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTDH U(27,ENTITIES"VALUE",1) = [INCLUDE]; 
        ITEM ENTDI U(27,ENTITIES"DFL  ",1) = [INCLUDE]; 
        ITEM ENTDJ U(27,ENTITIES"END  ",1) = [INCLUDE]; 
        ITEM MOD28 U(27,42,4)  =  [SUBTYPE"DECIMAL"]; 
        ITEM DEF28 U(27,46,14) =  [1];
  
  
# PARAMETER SET 35B                                                    #
  
        ITEM ENTDK U(28,ENTITIES"END  ",1) = [INCLUDE]; 
        ITEM ENTDL U(28,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM MOD29 U(28,42,4)  = [SUBTYPE"NULL"]; 
        ITEM DEF29 U(28,46,14) = [ENTITIES"NULL"];
  
  
# PARAMETER SET 36B                                                    #
  
        ITEM ENTDM U(29,ENTITIES"IN   ",1) = [INCLUDE]; 
        ITEM ENTDN U(29,ENTITIES"PR   ",1) = [INCLUDE]; 
        ITEM ENTDO U(29,ENTITIES"PU   ",1) = [INCLUDE]; 
        ITEM ENTDP U(29,ENTITIES"PT   ",1) = [INCLUDE]; 
        ITEM ENTDQ U(29,ENTITIES"EX   ",1) = [INCLUDE]; 
        ITEM ENTDR U(29,ENTITIES"ALLQ ",1) = [INCLUDE]; 
        ITEM MOD30 U(29,42,4)  = [SUBTYPE"NULL "];
        ITEM DEF30 I(29,46,14) = [VNTORD"NULL "]; 
  
  
# PARAMETER SET 37B                                                    #
  
        ITEM ENTEQ U(30,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTDT U(30,ENTITIES"HST  ",1) = [INCLUDE]; 
        ITEM MOD31 U(30,42,4)  = [SUBTYPE"VNAME "]; 
        ITEM DEF31 I(30,46,14) = [VNTORD"HST  "]; 
  
  
# PARAMETER SET 40B                                                    #
  
        ITEM ENTEK U(31,ENTITIES"CP   ",1) = [INCLUDE]; 
        ITEM MOD32 U(31,42,4)  = [SUBTYPE"NULL "];
        ITEM DEF32 I(31,46,14) = [VNTORD"NULL  "];
  
  
# PARAMETER SET 41B                                                    #
  
        ITEM ENTEL U(32,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTEM U(32,ENTITIES"BAN  ",1) = [INCLUDE]; 
        ITEM MOD33 U(32,42,4)  = [SUBTYPE"VNAME"];
        ITEM DEF33 I(32,46,14) = [VNTORD"BAN "];
  
  
# PARAMETER SET 42B                                                    #
  
        ITEM ENTEN U(33,ENTITIES"NULL ",1) = [INCLUDE]; 
        ITEM ENTEO U(33,ENTITIES"CR  ",1) = [INCLUDE];
        ITEM MOD34 U(33,42,4)  = [SUBTYPE"VNAME "]; 
        ITEM DEF34 U(33,46,14) = [VNTORD"CR"];
  
  
# PARAMETER SET 43B                                                    #
  
        ITEM ENTEP U(34,ENTITIES"ACK  ",1) = [INCLUDE]; 
        ITEM MOD35 U(34,42,4)  = [SUBTYPE"NULL "];
        ITEM DEF35 I(34,46,14) = [VNTORD"NULL "]; 
  
  
# PARAMETER SET 44B                                                    #
      ITEM ENTEU U(35,ENTITIES"NULL",1) = [INCLUDE];
      ITEM ENTER U(35,ENTITIES"TR",1) = [INCLUDE];
      ITEM ENTES B(35,ENTITIES"EPKEY",1) = [TRUE];
      ITEM ENTET U(35,ENTITIES"GROUP",1) = [INCLUDE]; 
      ITEM MOD36 U(35,42,4) = [SUBTYPE"TRTYPE"];
      ITEM DEF36 U(35,46,14) = [TRAINTYPE"DFAULT"]; 
  
  
# PARAMETER SET 45B                                                    #
      ITEM ENTEY U(36,ENTITIES"NULL ",1) = [INCLUDE]; 
      ITEM ENTEZ U(36,ENTITIES"SC   ",1) = [INCLUDE]; 
      ITEM ENTFG B(36,ENTITIES"EPKEY",1) = [TRUE];
      ITEM MOD37 U(36,42,4) = [SUBTYPE"NULL "]; 
      ITEM DEF37 I(36,46,14) = [VNTORD"NULL "]; 
  
  
        END 
  
  
# THE FOLLOWING BASED ARRAY IS AN ALTERNATE WAY OF ADDRESSING THE      #
# PARAMETER DESCRIPTOR ARRAY WHICH IS FORMATTED FOR PRESETTING (ABOVE) #
  
      BASED ARRAY PDTTAB[1:1] S(1); 
        BEGIN 
        ITEM VBITS     U(0,0,42);  # BIT MAP OF LEGAL VALUES           #
        ITEM MODE      U(0,42,4);  # MODE OF DEFAULT VALUE             #
        ITEM DEFAULT   I(0,46,14); # DEFAULT VALUE                     #
        ITEM PDT       I(0,0,WL);  # FULL WORD                         #
        END 
      CONTROL EJECT;
      FUNC SUPBLKS(NAME) C(7); # TRANSFORM BLANKS TO ZEROS IN A NAME   #
*IF,DEF,IMS 
 #
*1DC  SUPBLKS 
* 
*     1. FUNC NAME             AUTHOR               DATE
*        SUPBLKS               G. A. VALENCIA       JANUARY 24, 1980
* 
*     2. FUNCTIONAL DESCRIPTION 
*             CHANGES ANY TRAILING BLANKS IN A 7-CHARACTER NOS
*        NAME TO ZEROS (AS REQURIED BY MOST NOS FUNCTION PROCESSORS). 
* 
*     3. METHOD USED
*             SEARCH FOR BLANKS STARTING AT THE END OF A NOS NAME.
*        WHEN ONE IS FOUND, INSERT A CORRESPONDING ZERO INTO THE VALUE
*        RETURNED.  IF NON-BLANK, PICK UP THE BEGINING OF THE NAME AND
*        RETURN.
* 
*     4. ENTRY PARAMETERS 
*        NAME - CHARACTER STRING TO BE CONVERTED.  ASSUMED TO BE
*               THE LEFTMOST 7 CHARACTERS.
* 
*     5. VALUE RETURNED 
*        SUPBLKS - FIRST 7 CHARACTERS IN NAME WITH ANY TRAILING 
*                  BLANKS SUPRESSED.
* 
*     6. THIS FUNCTION IS LOCAL TO CRACKER. 
* 
 #
*ENDIF
      BEGIN     # SUPBLKS # 
      ITEM NAME C(10);         # INPUT PARAMETER                       #
      ITEM RETSTRING C(7);     # TEMPORARY STORAGE FOR RETURNED VALUE  #
      ITEM K;                  # INDUCTION VARIABLE                    #
  
      FOR K=6 STEP -1 UNTIL 0 
      DO                       # CHECK LEFTMOST CHARS, STARTING AT 6TH #
        BEGIN 
        IF C<K>NAME EQ " "
        THEN
          BEGIN                # CONVERT BLANK TO ZERO                 #
          C<K>RETSTRING = 0;
          END 
        ELSE
          BEGIN                # MOVE NAME TO THE RETURNED VALUE       #
          C<0,K+1>RETSTRING = C<0,K+1>NAME; 
          K = 0;               # NAME IS FOUND, TERMINATE LOOP         #
          END 
        END 
  
      SUPBLKS = RETSTRING;
      RETURN;                  # ENTIRE NAME CONVERTED TO ZEROS        #
      END       # SUPBLKS # 
      CONTROL EJECT;
      PROC DEFAULTS;         # APPLY DEFAULTS                          #
*IF DEF,IMS 
 #
*1DC  DEFAULTS
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DEFAULTS            A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE IS CALLED AFTER THE COMMAND LINE HAS BEEN SCANNED.
*        IT CHECKS TO MAKE SURE THAT ALL MANDATORY PARAMETERS ARE 
*        PRESENT AND THAT ALL DEFAULTS HAVE BEEN APPLIED. 
* 
*     3. METHOD USED
*        FOR OPTIONAL MISSING PARAMETERS, DEFAULTS, IF THEY EXIST, ARE
*        APPLIED.  FOR MANDATORY MISSING PARAMETERS, AN ERROR MESSAGE 
*        IS ISSUED. 
* 
*     4. ENTRY PARAMETERS 
*        PDESCS - THE ARRAY OF PARAMETER DESCRIPTORS
* 
*     5. EXIT PARAMETERS
*        THE FLAGS AND VALUE-CELLS OF CIT 
* 
*     6. COMDECKS USED
*        NONE.
* 
*     7. ROUTINES CALLED
*        NONE.
* 
*     8. CONSOLE MESSAGES 
*        A. REQUIRED PARAMETER MISSING
 #
*ENDIF
  
  
      BEGIN                  # BEGIN DEFAULTS                          #
  
      ITEM KK I;             # CONTROL VARIABLE # 
      ITEM JJ I;             # TEMPORARY #
  
      GROUPFLAG = FALSE;
      GROUPUSED = FALSE;
  
  
# PROCESS EACH POTENTIAL COMMAND PARAMETER IN TURN #
  
      FOR KK = 1 STEP 1 UNTIL NPARS DO
        BEGIN 
  
        IF B<ENTITIES"GROUP",1>XVBITS[KK] NQ 0
        THEN
          BEGIN              # MEMBER OF PARAMETER-GROUP               #
          GROUPFLAG = TRUE; 
          IF B<ENTITIES"USED",1>XVBITS[KK] NQ 0 
          THEN
            GROUPUSED = TRUE;      # AT LEAST ONE GROUP MEMBER WAS USED#
          END 
  
        IF B<ENTITIES"USED",1>XVBITS[KK] NQ 0 
        THEN
          TEST; 
  
        IF B<ENTITIES"EPKEY",1>XVBITS[KK] NQ 0
        THEN
          BEGIN              # EXPLICIT PARAMETER NAME SECTION FOR     #
                             # REP, PRI = 1, ETC                       #
          IF B<ENTITIES"NULL",1>XVBITS[KK] NQ 0 
          THEN
            TEST KK;         # OPTIONAL PARAMETER IS MISSING           #
          ELSE
            BEGIN            # MANDATORY PARAMETER MISSING             #
            ERRNR = S"MISPAR";
            ERRPRO; 
            END 
  
          END                # END OF EXPLICIT PARAMETER NAME SECTION  #
  
        ELSE
  
          BEGIN              # IMPLICIT PARAMETER NAME (FOR CR1,PU,FMT)#
  
          IF B<ENTITIES"NULL",1>XVBITS[KK] NQ 0 
          THEN
            BEGIN            # OPTIONAL VALUE KEYWORD MISSING/DEFAULT  #
            IF XMODE[KK] EQ SUBTYPE"NULL" 
            THEN
              TEST KK;       # NO DEFAULT PROVIDED                     #
            MTYPE = MAINTYPE"VALUE";
            STYPE = XMODE[KK];
            VALUE = XDEFAULT[KK]; 
            VNTX = VALUE; 
            IF  VDFLG[VNTX]             # MAKE SURE VNTX IS A VALUE    #
            AND STYPE EQ SUBTYPE"VNAME" # THAT MAPS INTO ARRAY VDFLG.  #
            THEN
              BEGIN 
              CIT$ORD = 1;   # DEVICE ORDINAL (IE. LP IMPLIES LP1, ETC)#
              END 
            VAL;             # TREAT AS ISOLATED VALUE ON LINE         #
            END              # END OF OPTIONAL VALUE KEYWORD MISSING   #
          ELSE
            BEGIN            # MANDATORY PARAMETER MISSING             #
            ERRNR = S"MISPAR";
            ERRPRO; 
            END 
  
          END                # END OF IMPLICIT PARAMETER NAME SECTION  #
  
        END                  # END OF FOR-LOOP #
  
      IF GROUPFLAG AND NOT GROUPUSED
      THEN
        BEGIN 
        ERRNR = S"MISPAR";
        ERRPRO; 
        END 
  
      RETURN; 
      END                    # END OF DEFAULTS                         #
  
  
  
  
      CONTROL EJECT;
      PROC ERRPRO;           # BUILD AN ERROR MESSAGE # 
*IF DEF,IMS 
 #
*1DC  ERRPRO
* 
*     1. PROC NAME           AUTHOR               DATE
*        ERRPRO              A. M. PRATT          77/02/08
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE BUILDS A 4-WORD ERROR MESSAGE IN THE COMMAND
*        LINE AREA.  THE MESSAGE CONSISTS OF BASIC TEXT PLUS THE
*        CURRENT SCAN TOKEN.
* 
*     3. METHOD USED. 
*        THE FIRST TEN CHARACTERS OF THE CURRENT TOKEN ARE MOVED AFTER
*        THE LAST CHARACTER (PLUS ONE) OF THE BASIC TEXT. 
* 
*     4. ENTRY PARAMETERS 
*        CIT$ERRTYPE         CONTAINS ERROR ORDINAL 
*        I                   CHARACTER POINTER WITH CURRENT SCAN POS
*        LASTI               VALUE OF I AT TOKEN START
* 
*     5. EXIT PARAMETERS
*        CIT$MESSAGE         FIRST 4 WORDS CONTAINS ERROR MESSAGE 
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        NONE 
* 
*     8. CONSOLE MESSAGES 
*        NOT APPLICABLE 
* 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF ERRPRO            #
  
# THE FOLLOWING TABLE GIVES THE TEXT OF ERROR MESSAGE SENT BACK TO THE #
# CONSOLE, THEIR LENGTH, AND WHETHER OR NOT THE CURRENT TOKEN IS TO BE #
# PRINTED # 
  
      ARRAY ERRTAB[1:NERRS] P(4); 
        BEGIN 
  
        ITEM EMESS C(0,0,30) = [           # ERROR TEXTS #
          "0PARAMETER DOUBLY SPECIFIED",         # DUPPAR # 
          "0ILLEGAL OR UNKNOWN DEVICE",          # ILLDEV # 
          "0IMPROPER VALUE TYPE",                # ILLVAL # 
          "0INVALID KEYWORD",                    # ILLKEY # 
          "0INVALID USER/FAMILY NAME",           # ILLUSR # 
          "0REQUIRED PARAMETER MISSING",         # MISPAR # 
          "0FAULTY PUNCTUATION",                 # ILLPUN # 
          "0INVALID COMMAND",                    # ILLCOM # 
          "0VALUE MISSING",                      # MISVAL # 
          "0NAME TOO LONG",                      # TOOLNG # 
          "0INVALID JOB NAME",                   # ILLJOB # 
          "0INVALID SYNTAX",                     # ILLSYN # 
          "0VALUE OF UNEXPECTED TYPE",           # ILLTYP # 
          "0VALUE OUT-OF-RANGE",                 # VRANGE # 
          "0INAPPROPRIATE KEYWORD"];             # INAKEY # 
  
        ITEM ELENGTH  I(3,42,18) = [       # LENGTH OF MESSAGE (CHARS) #
          27,                                    # DUPPAR # 
          26,                                    # ILLDEV # 
          20,                                    # ILLVAL # 
          16,                                    # ILLKEY # 
          25,                                    # ILLUSR # 
          27,                                    # MISPAR # 
          19,                                    # ILLPUN # 
          16,                                    # ILLCOM # 
          14,                                    # MISVAL # 
          14,                                    # TOOLNG # 
          17,                                    # ILLJOB # 
          15,                                    # ILLSYN # 
          25,                                    # ILLTYP # 
          19,                                    # VRANGE # 
          22];                                   # INAKEY # 
  
        ITEM ETOKEN  B(3,0,1) = [          # TRUE MEANS PRINT TOKEN # 
          FALSE,                                      # DUPPAR #
          TRUE,                                        # ILLDEV # 
          TRUE,                                       # ILLVAL #
          TRUE,                                       # ILLKEY #
          TRUE,                                       # ILLUSR #
          FALSE,                                      # MISPAR #
          FALSE,                                      # ILLPUN #
          TRUE,                                       # ILLCOM #
          FALSE,                                      # MISVAL #
          TRUE,                                       # TOOLNG #
          TRUE,                                       # ILLJOB #
          FALSE,                                      # ILLSYN #
          TRUE,                                       # ILLTYP #
          TRUE,                                       # VRANGE #
          TRUE];                                      # INAKEY #
  
        ITEM EFINAL B(3,1,1) = [           # TRUE MEANS FINAL ERROR    #
          TRUE,                                       # DUPPAR #
          TRUE,                                       # ILLDEV #
          TRUE,                                       # ILLVAL #
          TRUE,                                       # ILLKEY #
          TRUE,                                       # ILLUSR #
          FALSE,                                      # MISPAR #
          TRUE,                                       # ILLPUN #
          TRUE,                                       # ILLCOM #
          FALSE,                                      # MISVAL #
          TRUE,                                       # TOOLNG #
          TRUE,                                       # ILLJOB #
          TRUE,                                       # ILLSYN #
          FALSE,                                      # ILLTYP #
          TRUE,                                       # VRANGE #
          FALSE];                                     # INAKEY #
  
        END                  # END OF ERRTAB #
  
  
# MOVE ERROR MESSAGE AND, IF NEEDED, CURRENT TOKEN TO THE MESSAGE AREA #
  
      IF ERRNR EQ S"MISPAR" 
      THEN
        MISPARFLAG = TRUE;   # PARAMETER MISSING FOR THIS PRODUCTION   #
  
      IF NOT EFINAL[ERRNR] AND NOT FATALFLAG
      THEN
        GOTO TRY$AGAIN;      # GO TRY ANOTHER PRODUCTION               #
  
      NAME = C<LASTI+1,I-LASTI>CIT$MESSAGE;  # MOVE TOKEN TO NAME      #
      C<0,40>CIT$MESSAGE = EMESS[ERRNR];        # ERROR MESS TO LINE   #
  
      IF ETOKEN[ERRNR]
      THEN
        C<ELENGTH[ERRNR]+1,10>CIT$MESSAGE = NAME; 
  
      GOTO FATAL$ERROR;      # SYNTAX ERROR WITH ALL PRODUCTIONS - EXIT#
      END                    # END OF ERRPRO                           #
      CONTROL EJECT;
      PROC EVAL(J);          # EVALUATES A COMMAND PHRASE # 
*IF DEF,IMS 
 #
*1DC  EVAL
* 
*     1. PROC NAME           AUTHOR              DATE 
*        EVAL                A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS PROCEDURE ACCEPTS A COMMAND PHRASE SUCH AS PARAMETER-NAME,
*        (DESIGNATED BY J = 1) OR PARAMETER NAME = VALUE, (DESIGNATED 
*        BY J = 2).  IT THEN DOES CHECKING, AND, IF NO ERROR OCCURS,
*        IT SETS A FLAG OR A VALUE IN CIT.
* 
*     3. METHOD USED
*        FOR J = 1, THE -VALUE- IS SET TO THE DEFAULT VALUE FOR THIS
*        PARAMETER NAME.  FOR J = 1 OR 2 IT SPECIAL CASES SETTING 
*        FLAGS AND VALUE FOR EACH PARAMETER NAME
* 
*     4. ENTRY PARAMETERS 
*        J - COMMAND PHRASE TYPE
* 
*     5. EXIT PARAMETERS
*        VALUE CELLS OF CIT 
*        FLAGW - THE FLAG WORD IN CIT 
* 
*     6. COMDECKS CALLED
*        NONE.
* 
*     7. ROUTINES CALLED
*        FINDBIT             TO SEE IF A KEYWORD IS LEGAL IN THIS 
*                            CONTEXT
* 
*     8. CONSOLE MESSAGES 
*        NONE.
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF EVAL1             #
  
      DEF K #EVALK#;         # TEMPORARY #
      ITEM J I;              # PHRASE TYPE #
  
  
#  SEE IF PARAMETER WORD IS LEGAL FOR THIS COMMAND #
  
      FINDBIT(LVAL[PNTX],K);
      IF K EQ 0              # NOT FOUND #
      THEN
        BEGIN 
        ERRNR = S"INAKEY";
        ERRPRO; 
        END 
  
  
  
# HANDLE CASE WHERE NO VALUE FOLLOWS #
      IF J EQ 1 
      THEN
        BEGIN                # CHECK FOR LEGALITY OF "KEYWORD," FORM   #
        IF XMODE[K] EQ SUBTYPE"NULL"
        THEN
          BEGIN 
          ERRNR = S"MISVAL"; # VALUE MISSING AFTER PARAMETER NAME      #
          FATALFLAG = TRUE; 
          ERRPRO; 
          END 
        ELSE
          BEGIN              # SUBSTITUTE DEFAULT                      #
          VALUE = XDEFAULT[K];
          B<0,12>NAME = B<0,12>XDEFAULT[K];  # FOR FORMS CODE DEFAULT  #
          END 
        END 
  
      B<ENTITIES"USED",1>XVBITS[K] = 1;  # SET -USED- FLAG             #
  
  
# CHECK RANGE OF INTEGER VALUES                                        #
  
      IF UB[PNTX] NQ 0 AND J EQ 2 
      THEN
        IF VALUE LS LB[PNTX] OR VALUE GR UB[PNTX] 
        THEN
          BEGIN              # OUT-OF-RANGE                            #
          IF PNTX EQ 5 AND VALUE GR UB[PNTX]
          THEN
            BEGIN                      # REPEAT VALUE GREATER THAN 32  #
            VALUE = UB[PNTX]; 
            END 
          ELSE
            BEGIN 
            ERRNR = S"VRANGE";
            ERRPRO; 
            END 
          END 
  
  
      K = LVAL[PNTX] - ENTITIES"WID"; 
  
  
      SWITCH CASE 
          L1, 
          L2, 
          L3, 
          L4, 
          L5, 
          L6, 
          L7, 
          L8, 
          L9, 
          L10;
  
  
# HANDLE THE FLAG/VALUE OF EACH PARAMETER NAME AS A SPECIAL CASE       #
  
        BEGIN 
        GOTO CASE[K]; 
  
L1:                          # HANDLE WID # 
        CIT$WIDTH = VALUE;
      CIT$WIDFLAG = TRUE; 
        GOTO ENDCASE; 
  
L2:                          # HANDLE FAM # 
        CIT$FAMNAME = SUPBLKS(NAME);
        GOTO ENDCASE; 
  
L3:                          # HANDLE FORMS CODE #
        CIT$FORMS = NAME; 
        CIT$FMSFLAG = TRUE; 
        GOTO ENDCASE; 
  
L4:                          # HANDLE JOB NAME #
        CIT$JSN = NAME ;
        CIT$ZERO = 0 ;
        CIT$JOBFLAG = TRUE; 
        GOTO ENDCASE; 
  
L5:                          # HANDLE PRI # 
        CIT$PRIVALUE = VALUE; 
        CIT$PRIFLAG = TRUE; 
        GOTO ENDCASE; 
  
L6:                          # HANDLE REP # 
        CIT$REP = VALUE;
        CIT$REPFLAG = TRUE; 
        GOTO ENDCASE; 
  
L7:                          # HANDLE USR # 
        CIT$USERNUM = SUPBLKS(NAME);
        CIT$ZERO1 = 0;
        GOTO ENDCASE; 
L8:                          # HANDLE BLOCK SIZE CHANGE # 
        CIT$BLKSIZ = TRUE;
        CIT$BLKVAL = VALUE; 
        GOTO ENDCASE; 
L9:                                              # HANDLE TRAIN TYPE   #
        CIT$TRFLAG = TRUE;
        CIT$TRAIN = VALUE;                       # SET TRAIN TYPE      #
        GOTO ENDCASE; 
L10:                         # HANDLE SC #
        CIT$SCFLAG = TRUE;
        CIT$SCVALUE = SCVALUE;
  
ENDCASE:  
        END                  # END OF CASE STATEMENT #
  
      RETURN; 
      END                    # END OF EVAL #
  
  
  
  
      CONTROL EJECT;
      PROC FINDBIT(II,JJ);   # DETERMINE IF A PARTICULAR KEYWORD IS    #
                             # LEGAL IN A PARTICULAR CONTEXT           #
*IF DEF,IMS 
 #
*1DC  FINDBIT 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        FINDBIT             A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        DETERMINES WHETHER A KEYWORD IS LEGAL IN THE CONTEXT OF ANY OF 
*        THE PARAMETERS OF THIS COMMAND.
* 
*     3. METHOD USED
*        A KEYWORD (WHETHER A PARAMETER NAME OR A VALUE NAME) IS
*        REPRESENTED BY A BIT IN A PARTICULAR POSITION OF A COMPUTER
*        WORD.  FOR A PARTICULAR COMMAND, LEGAL KEYWORDS ARE
*        REPRESENTED BY BITS IN PARTICULAR POSITIONS OF A WORD.  ONE
*        WORD REPRESENTS KEYWORDS LEGAL FOR A GIVEN PARAMETER.
* 
*     4. ENTRY PARAMETER
*        II - BIT POSITION OF THE KEYWORD TO BE SEARCHED FOR
* 
*     5. EXIT PARAMETER 
*        JJ - ORDINAL OF THE PARAMETER WORD IN WHICH THE BIT IN 
*             QUESTION OCCURRED 
* 
*     6. COMDECKS CALLED
*        NONE.
* 
*     7. ROUTINES CALLED
*        NONE.
* 
*     8. CONSOLE MESSAGES 
*        A. INAPPROPRIATE KEYWORD 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF FINDBIT           #
  
      ITEM II   I;           # BIT NUMBER REQUIRED #
      ITEM JJ   I;           # NUMBER OF WORD WITH WANTED BIT # 
      ITEM KK   I;           # CONTROL VARIABLE # 
      ITEM TEMP I;           # TEMPORARY #
  
      JJ = 0; 
      TEMP = 0; 
      B<II,1>TEMP = 1;       # BECOMES SEARCH PARAMETER # 
  
      FOR KK = 1 STEP 1 UNTIL NPARS DO
        BEGIN 
        IF (XPDT[KK] LAN TEMP) NQ 0    # CHECKING FIRST 42 BITS ONLY   #
        THEN
          BEGIN              # FOUND #
          JJ = KK;
          END 
        END                  # END OF FOR-LOOP #
  
      RETURN; 
      END                    # END OF FINDBIT # 
  
  
  
  
      CONTROL EJECT;
      PROC GETATOM;          # FETCH ONE LEXICAL ATOM FROM COMMAND LINE#
*IF DEF,IMS 
 #
*1DC  GETATOM 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETATOM             A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE SCANS THE CHARACTERS OF THE COMMAND LINE AND
*        FORMS LEXICAL ATOMS WHICH ARE IDENTIFIED AND RETURNED TO THE 
*        CALLER.
* 
*     3. METHOD USED
*        THIS ROUTINE DECIDES, ON THE BASIS OF THE NEXT CHARACTER OF
*        THE COMMAND LINE, WHAT TYPE OF ATOM OCCURS NEXT AND CALLS THE
*        APPROPRIATE PROCEDURE TO PICK-UP THIS ATOM.
* 
*     4. ENTRY PARAMETERS 
*        CIT$TABLE - THIS INCLUDES THE COMMAND LINE AND THE NUMBER OF 
*                   CHARACTERS IN IT
* 
*     5. EXIT PARAMETERS
*        VALUE OR NAME - THE LEXICAL ATOM 
*        MTYPE - ATOM TYPE
*        STYPE - VALUE SUBTYPE
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        GETFC               GET FORMS CODE 
*        GETNEXTC            GET NEXT CHARACTER OF COMMAND LINE 
*        GETNAME             PICK-UP NAME ATOM
*        GETINT              PICK-UP DECIMAL OR OCTAL INTEGER 
*        GETDEL              PICK-UP DELIMITER
* 
*     8. CONSOLE MESSAGES 
*        A. IMPROPER TYPE VALUE 
* 
* 
 #
*ENDIF
  
      BEGIN                  # BEGIN MAIN SECTION OF GETATOM           #
  
  
      DEF K  #GETATOMK#;
  
  
      LASTI = I;
  
      IF RTYPE EQ MAINTYPE"VALUE" AND RSTYPE EQ SUBTYPE"FMSCODE"
         OR 
         RTYPE EQ MAINTYPE"VALUE" AND RSTYPE EQ SUBTYPE"TRTYPE" 
      THEN
        BEGIN                # PICK-UP FORMS CODE # 
        GETFC;
        RETURN; 
        END 
  
  
# PROCESS ACCORDING TO FIRST CHARACTER OF TOKEN # 
  
      SWITCH ACASE
          A1, 
          A2, 
          A3, 
          A4, 
          A5; 
  
      GETNEXTC;              # GET FIRST CHARACTER #
  
        BEGIN                # START CASE STATEMENT # 
        K = C<CHAR,1>CT - 1;
        GOTO ACASE[K];       # DECIDE BY CHARACTER TYPE # 
  
A1:                          # LETTER # 
A4:                          # OR SPECIAL CHARACTER # 
        GETNAME;
        GOTO ENDCASE; 
  
A2:                          # DIGIT                                   #
      IF RTYPE EQ MAINTYPE"VALUE" AND (RSTYPE EQ SUBTYPE"FAMNAME" OR
      RSTYPE EQ SUBTYPE"USRNAME") 
      THEN
        BEGIN                # FAMILY OR USER NAME STARTS WITH A DIGIT #
        GETNAME;
        GOTO ENDCASE; 
        END                  # FAMILY OR USER NAME STARTS WITH A DIGIT #
  
A5:                          # DIGIT, PLUS, OR MINUS SIGN              #
      IF RSTYPE EQ SUBTYPE"CLASS" 
      THEN
        GETNAME;             # SERVICE CLASS STARTS WITH A DIGIT       #
      ELSE
        GETINT;              # DIGIT, PLUS, OR MINUS SIGN              #
      GOTO ENDCASE; 
  
A3:                          # COMMA, EQUAL SIGN, BLANK, OR EOL # 
        GETDEL; 
  
ENDCASE:  
        END                  # END OF CASE STATEMENT #
  
  
# CHECK TYPE TOKEN VERSUS REQUIRED TYPE # 
  
      IF RTYPE EQ MAINTYPE"VALUE" AND RSTYPE NQ SUBTYPE"NULL" 
        AND (MTYPE NQ RTYPE OR STYPE NQ RSTYPE) 
      THEN
        BEGIN                # UNEXPECTED TOKEN # 
        ERRNR = S"ILLTYP";
        ERRPRO; 
        END 
  
      RTYPE = MAINTYPE"NULL";# EXPECTED VALUE ALREADY RECEIVED         #
  
      RETURN; 
      END                    # END OF GETATOM # 
  
  
  
  
      CONTROL EJECT;
      PROC GETCNAME;         # SCAN FOR COMMAND NAME #
*IF DEF,IMS 
 #
*1DC  GETCNAME
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETCNAME            A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE SCANS THE COMMAND LINE FOR AN UP TO 8 LETTER
*        COMMAND NAME. IT THEN LOOKS THE NAME UP IN THE COMMAND NAME
*        TABLE, CNTTAB. 
* 
*     3. METHOD USED
*        NOT APPLICABLE.
* 
*     4. ENTRY PARAMETERS 
*        NONE.
* 
*     5. EXIT PARAMETERS
*        CNTX - THE ORDINAL IN CNTX OF THE APPROPRIATE CNTTAB ENTRY 
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        GETNEXTC            GET NEXT COMMAND LINE CHARACTER
* 
*     8. CONSOLE MESSAGES 
*        A. INVALID COMMAND 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETCNAME          #
  
      DEF J #GETCNAMEJ#;
      DEF K #GETCNAMEK#;
  
  
      CNAME = " ";
      GETNEXTC; 
  
      FOR K = K WHILE CHAR EQ " " DO    # SKIP LEADING BLANKS # 
        GETNEXTC; 
  
      LASTI = I - 1;
  
  
# NOW PICKUP NAME # 
  
      FOR K = 0 STEP 1 WHILE (CTYPE NQ CTY"DELIM" AND K LQ 8) DO
        BEGIN 
        C<K,1>CNAME = CHAR; 
        LENGTH = K + 1; 
        GETNEXTC; 
        END 
  
      I = I - 1;             # SCAN HAS GONE TOO FAR                   #
      IF CTYPE NQ CTY"DELIM"
      THEN
        CNAME = "NONSENSE";  # CATCH ERROR LATER                       #
  
  
# SEARCH CNTTAB # 
  
      FOR K = 1 STEP 1 UNTIL NCNTS DO 
        BEGIN 
        IF CNAME EQ NAMEA[K] OR CNAME EQ NAMEB[K] 
        THEN
          BEGIN              # FOUND #
          CNTX = K; 
          RETURN; 
          END 
        END                  # END OF FOR-LOOP                         #
  
# NOT FOUND                                                            #
      ERRNR = S"ILLCOM";
      ERRPRO; 
      RETURN; 
  
      END                    # END OF GETCNAME #
  
  
      CONTROL EJECT;
      PROC GETDEL;           # SCAN FOR ONE OF THREE DELIMITERS        #
*IF DEF,IMS 
 #
*1DC  GETDEL
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETDEL              A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE SCANS FOR A COMMA OR A COMMA IMBEDDED IN BLANKS 
*        AN EQUAL SIGN OR AN EQUAL SIGN IMBEDDED IN BLANKS, OR SIMPLY 
*        A SERIES OF BLANKS.
* 
*     3. METHOD USED
*        NOT APPLICABLE.
* 
*     4. ENTRY PARAMETERS 
*        NONE.
* 
*     5. EXIT PARAMETERS
*        MTYPE - SPECIFIES WHICH DELIMITER OCCURRED.
* 
*     6. COMDECKS CALLED
*        NONE.
* 
*     7. ROUTINES CALLED
*        GETNEXTC            FETCHES NEXT CHARACTER FROM COMMAND LINE 
* 
*     8. CONSOLE MESSAGES 
*        A. FAULTY PUNCTUATION
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETDEL            #
  
      DEF K #GETDELK#;
      ITEM GO$ON  B;         # FOR-LOOP FLAG #
  
  
# PICK-UP DELIMITERS COMMASP, EQUALSP, OR EOLSP # 
  
      DELCHAR = " ";
      I = I - 1;             # GET LAST SCAN CHARACTER AGAIN #
      GO$ON = TRUE; 
  
      FOR K = K WHILE GO$ON DO     # SCAN FOR , = OR EOL IN BLANKS #
        BEGIN 
        GETNEXTC; 
        IF CTYPE EQ CTY"DELIM"
        THEN
          BEGIN              # ,/BLANK/=/EOL #
          IF CHAR EQ " "
          THEN               # SKIP BLANKS #
            TEST; 
  
          IF DELCHAR NQ " " 
          THEN
            BEGIN 
            ERRNR = S"ILLPUN";     # MULTIPLE DELIMITERS               #
            ERRPRO; 
            END 
  
          ELSE
            BEGIN 
            DELCHAR = CHAR;  # SAVE DELIMITER                          #
            GO$ON = NOT EOLFLAG;
            END 
          END                # CHAR IS DELIMITER #
  
        ELSE
          GO$ON = FALSE;     # STOP THE SCAN #
        END                  # END OF FOR-LOOP #
  
      IF DELCHAR EQ "=" 
      THEN
        MTYPE = MAINTYPE"EQUALSP";
      ELSE
        MTYPE = MAINTYPE"COMMASP";
  
      I = I - 1;
      RETURN; 
  
      END                    # END OF GETDEL #
  
  
  
  
      CONTROL EJECT;
      PROC GETFC;            # PICKS UP FORMS CODE                     #
*IF DEF,IMS 
 #
*1DC  GETFC 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETFC               A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        RETURNS TO CALLER THE NEXT TWO CHARACTERS OF THE COMMAND LINE
* 
*     3. METHOD USED
*        NOT APPLICABLE 
* 
*     4. ENTRY PARAMETERS 
*        CIT$TABLE - COMMAND INTERFACE TABLE
* 
*     5. EXIT PARAMETERS
*        NAME - FIRST TWO CHARACTERS ARE THE FORMS CODE 
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        GETNEXTC            FETCHES NEXT INPUT CHARACTER 
* 
*     8. CONSOLE MESSAGES 
*        A. VALUE MISSING 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETFC             #
  
      NAME = " "; 
      GETNEXTC;              # GET FIRST CHARACTER #
      C<0,1>NAME = CHAR;
      EFLAG = CTYPE NQ CTY"LETTER" AND CTYPE NQ CTY"DIGIT"; 
      GETNEXTC; 
      C<1,1>NAME = CHAR;     # GET SECOND CHARACTER # 
      EFLAG = EFLAG OR CTYPE NQ CTY"LETTER" AND CTYPE NQ CTY"DIGIT";
      GETNEXTC; 
  
      I = I - 1;                                 # SCANED TOO FAR      #
      IF EFLAG OR CTYPE NQ CTY"DELIM" 
      THEN
        BEGIN                # FORMS CODE NOT ALPHANUMERIC             #
        ERRNR = S"ILLVAL";
        ERRPRO; 
        END 
      IF RSTYPE EQ SUBTYPE"TRTYPE"
      THEN
        BEGIN                                    # TRAIN PARAMETER FND #
        VALUE = 77; 
        FOR J=0 STEP 1 UNTIL 4 DO 
          BEGIN                                  # SEARCH TRAIN TYPE   #
          IF C<0,2>NAME EQ C<J*2,2>TYPETR 
          THEN
            BEGIN 
            VALUE = J;
            END 
          END 
        IF VALUE GR 4                            # ILLEGAL VALUE       #
        THEN
          BEGIN 
          ERRNR = S"ILLVAL";
          VALUE = ZERO; 
          ERRPRO; 
          END 
        STYPE = SUBTYPE"TRTYPE";
        END 
      ELSE
        BEGIN                                    # FORMS CODE FOUND    #
        STYPE = SUBTYPE"FMSCODE"; 
        END 
  
      MTYPE = MAINTYPE"VALUE";
      RTYPE = MAINTYPE"NULL";      # ALREADY RECEIVED REQUIRED VALUE   #
      RETURN; 
  
      END                    # END OF GETFC # 
  
  
  
  
      CONTROL EJECT;
      PROC GETINT;           # PICKS UP AN INTEGER FROM COMMAND LINE   #
*IF DEF,IMS 
 #
*1DC  GETINT
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETINT              A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        PICKS UP A DECIMAL OR OCTAL INTEGER, DIGIT BY DIGIT, AND 
*        CONVERTS IT TO BINARY. THE RESULT IS LEFT IN -VALUE- 
* 
*     3. METHOD USED
*        NOT APPLICABLE 
* 
*     4. ENTRY PARAMETERS 
*        RSTYPE - TELLS WHETHER THE INTEGER IS DECIMAL OR OCTAL 
* 
*     5. EXIT PARAMETERS
*        VALUE - THE BINARY INTEGER VALUE 
*        STYPE - TELLS WHETHER THE INTEGER IS DECIMAL OR OCTAL
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        GETNEXTC            FETCHES ONE CHARACTER FROM THE COMMAND 
* 
*     8. CONSOLE MESSAGES 
*        NONE 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETINT            #
  
      DEF K #GETINTK#;
  
  
      EFLAG = FALSE;
      VALUE = 0;
      MTYPE = MAINTYPE"VALUE";
      MINUSFLAG = CHAR EQ "-";
      IF CTYPE EQ CTY"SIGN" 
      THEN
        GETNEXTC;            # SKIP OVER PLUS OR MINUS SIGN            #
  
      IF RSTYPE EQ SUBTYPE"OCTAL" 
      THEN
        BEGIN                # OCTAL INTEGER #
        STYPE = SUBTYPE"OCTAL"; 
        BASE = 8; 
        END 
      ELSE
        BEGIN                # DECIMAL INTEGER #
        STYPE = SUBTYPE"DECIMAL"; 
        IF RSTYPE  EQ SUBTYPE"ADECIMAL" 
        THEN  STYPE = SUBTYPE"ADECIMAL"  ;
        BASE = 10;
        END 
  
  
# PICK-UP INTEGER # 
  
      FOR K = 0 STEP 1 WHILE CTYPE EQ CTY"DIGIT" DO 
        BEGIN 
        BINVAL = CHAR - "0";
        EFLAG = BINVAL GQ BASE OR EFLAG;
        VALUE = BASE*VALUE + BINVAL;
        GETNEXTC; 
        END 
  
      IF RSTYPE EQ SUBTYPE"ADECIMAL"  AND 
         MINUSFLAG           # VERIFY ABSOLUTE.                        #
      THEN EFLAG = TRUE;
      IF EFLAG               # BAD DIGIT OCCURRED # 
      THEN
        BEGIN 
        ERRNR = S"ILLVAL";
        I = I - 1;
        ERRPRO; 
        END 
  
      IF MINUSFLAG
      THEN
        VALUE = -VALUE; 
      I = I - 1;             # SCAN HAS GONE ONE TOO FAR #
      RETURN; 
  
      END                    # END OF GETINT #
  
  
  
  
      CONTROL EJECT;
      PROC GETNAME;          # SCAN FOR A 1-7 CHARACTER NAME #
*IF DEF,IMS 
 #
*1DC  GETNAME 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETNAME             A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE PICKS UP ALL NAMES BUT COMMAND NAMES. THESE 
*        INCLUDE DEVICE DESIGNATORS WHOSE TRAILING DIGITS ARE STRIPPED
*        OFF AND PLACED IN CIT$ORD. 
* 
*     3. METHOD USED
*        A CHARACTER BY CHARACTER EXAMINATION OF THE COMMAND LINE 
* 
*     4. ENTRY PARAMETERS 
*        RTYPE  - TYPE OF LEXICAL ATOM EXPECTED BY CALLER 
*        RSTYPE - VALUE SUBTYPE OF LEXICAL ATOM EXPECTED BY CALLER
* 
*     5. EXIT PARAMETERS
*        NAME - THE SCANNED FOR NAME, LEFT-ADJUSTED IN BLANKS 
*        LENGTH - LENGTH OF NAME IN CHARACTERS
*        MTYPE - RECORDS THAT NAME IS OF TYPE -VALUE- 
*        STYPE - SUBTYPES NAME AS JOB NAME, FAMILY NAME, ETC
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        GETNEXTC            FETCHES ONE CHARACTER FROM COMMAND LINE
*        SEARCH              ROUTINE TO PERFORM TABLE(S) LOOKUP ON NAME 
* 
*     8. CONSOLE MESSAGES 
*        A. NAME TOO LONG 
*        B. INVALID JOB NAME
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETNAME           #
  
      DEF K #GETNAMEK#; 
  
  
      DEVO = -1;
      EFLAG = FALSE;
      NAME = " "; 
  
  
# SEE IF USER/FAMILY NAME IS EXPECTED # 
  
      MTYPE = MAINTYPE"VALUE";
      STYPE = SUBTYPE"NULL";
      IF RTYPE EQ MAINTYPE"VALUE" AND (RSTYPE EQ SUBTYPE"USRNAME" 
        OR RSTYPE EQ SUBTYPE"FAMNAME" OR RSTYPE EQ SUBTYPE"FMSCODE")
      THEN
        STYPE = RSTYPE; 
  
  
# NOW PICKUP NAME ITSELF #
  
      FOR K = 0 STEP 1 WHILE (CTYPE NQ CTY"DELIM") DO 
        BEGIN                # BEGIN NAME PICKUP                       #
        IF CTYPE EQ CTY"SPECIAL"
        THEN
          BEGIN              # SPECIAL CHARACTER                       #
          IF STYPE NQ SUBTYPE"USRNAME" OR CHAR NQ "*" 
          THEN
            EFLAG = TRUE; 
          END                # SPECIAL CHARACTER                       #
        C<K,1>NAME = CHAR;
        IF K GQ 9 
        THEN
          K = 9;
        LENGTH = K + 1; 
        GETNEXTC;            # GET NEXT CHARACTER # 
        END                  # END OF NAME PICKUP                      #
  
      I = I - 1;             # SCAN HAS GONE ONE TOO FAR #
  
      IF LENGTH GR 7
      THEN
        BEGIN 
        ERRNR = S"TOOLNG";
        ERRPRO; 
        END 
  
  
        IF RSTYPE EQ SUBTYPE"NULL" AND LENGTH EQ 4
        OR RSTYPE EQ SUBTYPE"JOBNAME" 
      THEN
        BEGIN 
        STYPE = SUBTYPE"JOBNAME";  # JOB NAME # 
        PNTX = PNTJOBORD;    # NEEDS SETTING IF "JOB=" IS MISSING      #
  
          IF EFLAG OR LENGTH NQ 4 
        THEN
          BEGIN 
          ERRNR = S"ILLJOB";
          ERRPRO; 
          END 
  
        END 
  
      IF EFLAG AND (STYPE EQ SUBTYPE"USRNAME" 
        OR STYPE EQ SUBTYPE"FAMNAME") 
      THEN
        BEGIN 
        ERRNR = S"ILLUSR";
        ERRPRO; 
        END 
  
  
      IF RSTYPE EQ SUBTYPE"CLASS" AND (C<0,1>NAME LS "A" OR 
         C<0,1>NAME GR "9" OR LENGTH NQ 2)
      THEN
        BEGIN                # SERVICE CLASS OUT OF RANGE              #
        ERRNR = S"VRANGE";
        ERRPRO; 
        END                  # SERVICE CLASS OUT OF RANGE              #
      ELSE
        IF LENGTH EQ 2 AND RSTYPE EQ SUBTYPE"CLASS" 
        THEN
          BEGIN              # VALID SERVICE CLASS ENTERED             #
          MTYPE = MAINTYPE"VALUE";
          STYPE = SUBTYPE"CLASS"; 
          SCVALUE = C<0,2>NAME;  # SAVE SERVICE CLASS VALUE            #
        END                  # VALID SERVICE CLASS ENTERED             #
  
  
# CHECK FOR DEVICE DESIGNATOR (E.G. CR5) #
  
      K = C<2,1>NAME; 
  
      IF LENGTH EQ 3 AND C<K,1>CT EQ CTY"DIGIT" AND STYPE NQ
      SUBTYPE"USRNAME" AND STYPE NQ SUBTYPE"FAMNAME"
      THEN
        BEGIN 
        DEVO = K - "0"; 
        C<2,1>NAME = " ";    # STRIP DESIGNATOR OF DIGIT #
        END 
  
  
# IF NOT A USER-NAME, FAM-NAME, JOB-NAME, OR SC, IT MUST BE A VALUE OR #
# PARAMETER NAME - GO SEARCH TABLES # 
  
      IF STYPE EQ SUBTYPE"NULL" 
      THEN
        IF NAME EQ "ALL"     # SUBTYPE UNDEFINED                       #
        THEN
          BEGIN              # KEYWORD -ALL- IS A SPECIAL CASE         #
          VNTX = ALLX[CNTX]; # MULTIPLE -ALL- INDICES                  #
          STYPE = SUBTYPE"VNAME"; 
  
          IF VNTX EQ 0
          THEN
            BEGIN            # "ALL" ILLEGAL ON THIS PRODUCTION        #
            ERRNR = S"INAKEY";
            ERRPRO; 
            END 
  
          END 
        ELSE
          SEARCH;            # LOOKUP NAME IN KEYWORD TABLES           #
      RETURN; 
  
      END                    # END OF GETNAME # 
  
  
  
  
      CONTROL EJECT;
      PROC GETNEXTC;         # FETCH NEXT SCAN CHARACTER FROM COMMAND  #
*IF DEF,IMS 
 #
*1DC  GETNEXTC
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETNEXTC            A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        RETURNS TO CALLER THE NEXT CHARACTER TO BE PROCESSED IN THE
*        COMMAND
* 
*     4. ENTRY PARAMETERS 
*        CIT$TABLE - THE COMMAND INTERFACE TABLE
* 
*     5. EXIT PARAMETERS
*        CHAR - THE NEXT SCAN CHARACTER 
*        CTYPE - TYPE OF CHAR 
* 
*     6. COMDECKS CALLED
*        NONE 
* 
*     7. ROUTINES CALLED
*        NONE 
* 
*     8. CONSOLE MESSAGES 
*        NONE 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF GETNEXTC          #
  
      I = I + 1;
  
      IF I GQ NCHARS         # IS THIS END-OF-LINE #
      THEN
        BEGIN 
        CHAR = ","; 
        CTYPE = CTY"DELIM"; 
        EOLFLAG = TRUE; 
        END 
      ELSE
        BEGIN 
        CHAR = C<I,1>CIT$MESSAGE; 
        CTYPE = C<CHAR,1>CT;
        END 
  
      RETURN; 
  
      END                    # END GETNEXTC                            #
  
  
  
  
      CONTROL EJECT;
      PROC SEARCH;           # SEARCH FOR NAME IN TABLES #
*IF DEF,IMS 
 #
*1DC  SEARCH
* 
*     1. PROC NAME           AUTHOR              DATE 
*        SEARCH              A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        MAKES A SEARCH FOR -NAME- IN THE PARAMETER NAME TABLE (PNTTAB) 
*        AND THE VALUE NAME TABLE (VNTTAB) AND RETURNS WHICH TABLE THE
*        NAME WAS FOUND IN ALONG WITH THE TABLE ORDINAL 
* 
*     3. METHOD USED
*        STRAIGHTFORWARD LINEAR SEARCH
* 
*     4. ENTRY PARAMETERS 
*        NAME - 1-7 CHARACTER NAME TO SEARCH FOR
* 
*     5. EXIT PARAMETERS
*        MTYPE NAME-S TYPE
*        STYPE - NAME-S SUBTYPE 
*        PNTX - ORDINAL IN PNTTAB (SET IF NAME IS IN PNTTAB)
*        VNTX - ORDINAL IN VNTTAB (SET IF NAME IS IN VNTTAB)
* 
*     6. COMDECKS CALLED
* 
*     7. ROUTINES CALLED
*        NONE.
* 
*     8. CONSOLE MESSAGES 
*        A. ILLEGAL OR UNKNOWN DEVICE 
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF SEARCH            #
  
      MTYPE = MAINTYPE"VALUE";
  
# SEARCH IN PARAMETER NAME TABLE #
  
      FOR K = 0 STEP 1 UNTIL NPNTM DO 
        BEGIN 
        IF NAME EQ PNAME[K] 
        THEN
          BEGIN              # FOUND #
          PNTX = K; 
          MTYPE = MAINTYPE"PNAME";
          STYPE = SUBTYPE"NULL";
          RETURN; 
          END                # END OF -FOUND- # 
        END                  # END OF FOR-LOOP #
  
  
# SEARCH FOR NAME IN VNTTAB                                            #
  
      FOR K = 1 STEP 1 UNTIL NVNTS DO 
        BEGIN                # BEGIN SEARCH FOR-LOOP                   #
        IF NAME EQ VNAME[K] 
        THEN
          BEGIN              # BEGIN FOUND BLOCK                       #
          VNTX = K; 
          STYPE = SUBTYPE"VNAME"; 
  
          IF VDFLG[K]        # IS NAME A DEVICE PREFIX                 #
          THEN
            IF DEVO GQ 0     # DEVICE PREFIX                           #
            THEN
              BEGIN          # PREFIX + ORDINAL - CR2,LP5,ETC          #
              CIT$ORD = DEVO; 
              IF DEVO GR 7
              THEN
                BEGIN        # BAD ORDINAL                             #
                ERRNR = S"ILLDEV";
                ERRPRO; 
                END 
              END 
            ELSE
              IF VDAFLG[K]   # PREFIX ONLY - CR,CRA,ETC                #
              THEN
                CIT$ORD = 0; # -ALL- PREFIX, CRA,LPA,ETC               #
              ELSE
                CIT$ORD = 1; # REGULAR PREFIX ONLY - CR=CR1,LP=LP1,ETC #
          ELSE
            IF DEVO GQ 0     # NAME IS NOT A DEVICE PREFIX             #
            THEN
              BEGIN          # NON-PREFIX WITH ORDINAL                 #
              ERRNR = S"ILLDEV";
              ERRPRO; 
              END 
  
          RETURN; 
          END                # END OF FOUND BLOCK                      #
  
        END                  # END OF SEARCH FOR-LOOP                  #
  
      ERRNR = S"ILLKEY";     # FALL-THROUGH MEANS NAME UNDEFINED       #
      ERRPRO; 
      RETURN; 
  
      END                    # END OF SEARCH PROCEDURE                 #
  
  
      CONTROL EJECT;
      PROC VAL;              # HANDLE COMMAND PHRASE WITH VALUE ONLY #
*IF DEF,IMS 
 #
*1DC  VAL 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        VAL                 A M PRATT           77/01/27 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE CHECKS TO SEE IF THIS TYPE OF VALUE AND THE VALUE 
*        ITSELF ARE APPROPRIATE TO THIS COMMAND. IF EVERYTHING IS OK
*        THE APPROPRIATE VALUE-CELL AND/OR FLAG BIT IS SET IN CIT.
* 
*     3. METHOD USED
*        FINDBIT IS USED TO TELL IF A VALUE-TYPE IS APPROPRIATE TO THIS 
*        COMMAND.  VNTTAB IS USED TO SET THE CORRECT FLAGS. 
* 
*     4. ENTRY PARAMETERS 
*        STYPE - INDICATES THE VALUE TYPE 
*        VNTX  - IF VALUE IS A VALUE-NAME, THIS IS ITS VNTTAB ORDINAL 
*        VALUE - THE VALUE ITSELF, IF AN INTEGER
*        NAME - THE VALUE ITSELF, IF A NAME 
* 
*     5. EXIT PARAMETERS
*        VALUE CELLS OF CIT 
*        FLAGW - FLAGS OF CIT 
* 
*     6. COMDECKS USED
*        NONE.
* 
*     7. ROUTINES CALLED
*        FINDBIT             TO SEE IF A VALUE-NAME OR VALUE TYPE IS
*                            LEGAL IN THIS CONTEXT
* 
*     8. CONSOLE MESSAGES 
*        NONE.
 #
*ENDIF
  
  
      BEGIN                  # BEGIN MAIN SECTION OF VAL               #
  
      ITEM II  I;            # BIT NUMBER REPRESENTING VALUE OR TYPE #
      ITEM JJ  I;            # INDEX OF PARAMETER WORD FOR VALUE #
  
      IF STYPE EQ SUBTYPE"DECIMAL"
      THEN
        BEGIN                # ISOLATED INTEGER # 
        II = ENTITIES"VALUE"; 
        CIT$SKPVALUE = VALUE; 
  
        IF VALUE LS (-4095) OR VALUE GR 4095
        THEN
          BEGIN              # SKIP-VALUE IS OUT-OF-RANGE              #
          ERRNR = S"VRANGE";
          ERRPRO; 
          END                # SKIP-VALUE IS OUT-OF-RANGE              #
  
        END 
      ELSE
        IF STYPE EQ SUBTYPE"JOBNAME"
        THEN
          BEGIN              # ISOLATED JOB NAME #
          II = ENTITIES"JVAL";
        CIT$JSN = NAME ;
        CIT$ZERO = 0 ;
          CIT$JOBFLAG = TRUE; 
          END 
        ELSE
          IF STYPE EQ SUBTYPE"VNAME"
          THEN
            BEGIN            # ISOLATED VALUE NAME #
            II = VLVAL[VNTX]; 
            IF VFB[VNTX] NQ 0 
            THEN
              B<VFB[VNTX],1>CIT$FLAGW = 1; #SET VALUE NAME FLAG        #
                  IF VDFLG[VNTX]
            THEN
              CIT$DEVT = VOVAL[VNTX];    # VALUE IS DEVICE TYPE # 
            END 
  
  
# DETERMINE IF VALUE IS LEGAL WITH THIS COMMAND # 
  
      FINDBIT(II,JJ);        # FIND PARAMETER WORD WHICH ALLOWS VALUE  #
  
      IF JJ EQ 0
      THEN
        BEGIN 
        ERRNR = S"ILLTYP";
        IF STYPE EQ SUBTYPE"VNAME"
        THEN
          ERRNR = S"INAKEY";
        ERRPRO; 
        END 
  
      IF B<ENTITIES"USED",1>XVBITS[JJ] NQ 0 AND 
        B<ENTITIES"MULTI",1>XVBITS[JJ] EQ 0 
      THEN
        BEGIN                # PARAMETER SET TWICE #
        ERRNR = S"DUPPAR";
        ERRPRO; 
        END 
  
      B<ENTITIES"USED",1>XVBITS[JJ] = 1;
      RETURN; 
  
      END                    # END OF VAL # 
      CONTROL EJECT;
# BEGIN EXECUTABLE CODE OF CRACKER #
  
      NCHARS = CIT$NOCHARS; 
      P<PDTTAB> = LOC(PDTSET);
      CIT$CMDTYPE = S"NOCOMMAND"; 
      CIT$NOCHARS = 0;       # THIS CELL USED ALSO BY FC #
      I = -1; 
      MISPARFLAG = FALSE; 
      FATALFLAG = FALSE;
      MTYPE = 0;
      STYPE = 0;
      NPARS = 0;
      RTYPE = 0;
      RSTYPE = 0; 
      ERRNR = S"NOERROR"; 
      EOLFLAG = FALSE;
      LASTI = I;
      GETCNAME;              # PICK-UP COMMAND NAME # 
      GETATOM;               # MUST BE A DELIMITER - SKIP IT           #
      ISAVE = I;             # SAVE SCAN POINTER FOR NEXT PASS (IF ANY)#
  
  
# COMPLICATED COMMANDS REQUIRE MULTIPLE PRODUCTIONS                    #
# RUN THROUGH EVERYTHING FOR EACH PRODUCTION #
  
      FOR CNTX = CNTX STEP 1 WHILE CNAME EQ NAMEA[CNTX] OR
                                   CNAME EQ NAMEB[CNTX] DO
        BEGIN                # BEGIN FOR-LOOP ON CNTX                  #
        EOLFLAG = FALSE;
        I = ISAVE;           # RESET SCAN POINTER # 
        J = 1;
        LASTI = I;
        NPARS = 0;
        CIT$FLAGS = 0;       # INITIALIZE FLAGS                        #
        CIT$SCFLAG = FALSE; 
        ERRNR = 0;
  
  
# TRANSFER SCATTERED PARAMETER DESCRIPTORS TO CONTIGUOUS CELLS #
  
        FOR K = 0 STEP 1 WHILE J NQ 0 DO
          BEGIN 
          J = C<K,1>PDI[CNTX];
          NPARS = NPARS + 1;
          XPDT[NPARS] = PDT[J]; 
          END 
  
        NPARS = NPARS - 1;   # NPARS BUMPED TOO OFTEN # 
  
  
# IN THE CODE BELOW, THE RBF COMMAND IS PARSED. A PARTICULAR ROUTINE IS#
# CALLED WHEN A PARTICULAR LEXICAL ATOM IS RECEIVED WHILE -CRACKER- IS #
# IN A PARTICULAR STATE # 
  
        FOR IPARS = 1 STEP 1 WHILE NOT EOLFLAG DO 
          BEGIN              # THERE SHOULD BE ONE -PHRASE- TO PARSE #
                             # FOR EACH MANDATORY PARAMETER # 
  
          RTYPE = MAINTYPE"NULL"; 
          RSTYPE = SUBTYPE"NULL"; 
          SKIPSTATE = 0;
  
          FOR NSTATE = 1 STEP 1 UNTIL 5 DO
  
            BEGIN            # CRACKER IS IN STATE = NSTATE # 
  
            IF SKIPSTATE GR 0 AND NSTATE LS SKIPSTATE 
            THEN
              TEST NSTATE;
  
  
            SWITCH SCASE
          CONTINUE$,
          ERROR$, 
          SKIP$,
          EVAL1$, 
          EVAL2$, 
          EVAL3$, 
          SETMODE$, 
          ENDCM$; 
  
            GETATOM;         # GET NEXT LEXICAL ATOM #
            ACTION = 0; 
            C<9,1>ACTION = C<MTYPE-1,1>XSTATE[NSTATE] - 1;
  
              BEGIN          # ROUTE ACCORDING TO LEXICAL ATOM #
              GOTO SCASE[ACTION]; 
  
CONTINUE$:  
              GOTO ENDCASE; 
  
ERROR$: 
              ERRNR = S"ILLSYN";
              CIT$CMDTYPE = S"NOCOMMAND"; 
              ERRPRO; 
              GOTO ENDCASE; 
  
SKIP$:  
              SKIPSTATE = 5;
              GOTO ENDCASE; 
  
EVAL1$:                      # PARAMETER NAME - NO VALUE               #
              EVAL(1);
              SKIPSTATE = 6;
              GOTO ENDCASE; 
  
EVAL2$:                      # PARAMETER NAME WITH VALUE               #
              EVAL(2);
              SKIPSTATE = 6;
              GOTO ENDCASE; 
  
EVAL3$:                      # UNACCOMPANIED VALUE                     #
              VAL;
              GOTO ENDCASE; 
  
  
SETMODE$:                    # SET MODE REQUIRED BY EXPLICIT PARAM NAME#
              RTYPE = MAINTYPE"VALUE";
              RSTYPE = RSUBTYPE[PNTX];
              GOTO ENDCASE; 
  
ENDCM$:                      # END-OF-LINE READ AFTER LAST PARAMETER   #
              TEST IPARS; 
  
ENDCASE:  
  
              END            # END OF CASE STATEMENT #
  
            END              # END OF FOR-LOOP ON NSTATE #
  
          END                # END OF FOR-LOOP ON IPARS # 
  
        DEFAULTS;            # APPLY DEFAULTS                          #
        IF CMDT[CNTX] EQ S"SET" 
           AND
           CIT$TRFLAG 
        THEN
          BEGIN                                  # SET,TR COMMAND      #
  
          IF CIT$DEVT EQ DEVICETYPE"LINE$PRINTER" 
          THEN
            BEGIN                                # SET,LP,TR COMMAND   #
            IF CIT$TRAIN EQ TRAINTYPE"DFAULT" 
            THEN
              BEGIN 
              CIT$TRAIN = TRAINTYPE"ASCII64";    # DEFAULT PRINT TRAIN #
              END 
            IF CIT$TRAIN GR TRAINTYPE"ASCII95"
            THEN
              BEGIN                              # SET,LP,TR=T6 CMD    #
              ERRNR = S"ILLTYP";
              ERRPRO;                            # SEND ERROR MESSAGE  #
              END                                # SET,LP,TR=T8 CMD    #
            END 
          IF CIT$DEVT EQ DEVICETYPE"PUNCH"
          THEN
            BEGIN                                # SET,CP,TR COMMAND   #
            ERRNR = S"INAKEY";                   # TR PARAMETER ILLEGAL#
            END 
          IF CIT$DEVT EQ DEVICETYPE"PLOTTER"
          THEN
            BEGIN                                # SET,PL,TR COMMAND   #
            IF CIT$TRAIN EQ TRAINTYPE"DFAULT" 
            THEN
              BEGIN 
              CIT$TRAIN = TRAINTYPE"SIXBIT";
              END 
            IF CIT$TRAIN LQ TRAINTYPE"ASCII95"
            THEN
              BEGIN                              # SET,PL,TR=A6 CMD    #
              ERRNR = S"ILLTYP";                 # ILLEGAL TRAIN TYPE  #
              ERRPRO; 
              END                                # SET,PL,TR=A9 CMD    #
            ELSE
              BEGIN                              # SET,PL,TR=T6 CMD    #
              CIT$TRAIN = CIT$TRAIN - TRAINTYPE"SIXBIT";
              END                                # SET,PL,TR=T8 CMD    #
            END 
          END                                    # SET,TR COMMAND      #
        IF ERRNR EQ 0 
        THEN
          BEGIN              # EVERYTHING OK                           #
          CIT$CMDTYPE = CMDT[CNTX]; 
          C<0,40>CIT$MESSAGE = "OK";
          RETURN; 
          END 
  
TRY$AGAIN:  
  
        END                  # END OF FOR-LOOP ON CNTX                 #
  
      IF ERRNR EQ S"INAKEY" AND MISPARFLAG
      THEN
        ERRNR = S"MISPAR";
  
      FATALFLAG = TRUE; 
      ERRPRO;                # OUT OF PRODUCTIONS - FATAL ERRORS       #
  
FATAL$ERROR:  
      RETURN;                # RETURN AFTER RECEIPT OF FATAL ERROR     #
  
      END                    # END OF CRACKER # 
TERM
