Retro1.org codex

*DECK     NAMI
  PRGM NAMI;
 
 
 
# 
  
  
                           NAMI GENERAL DESCRIPTION 
  
     NAMI IS THE NETWORK (NAM) INITIATOR PROGRAM.  THE OBJECTIVE
     OF NAMI IS TO ROUTE A NUMBER OF JOBS, THE NETWORK JOBS, TO 
     THE INPUT QUEUE, FROM WHENCE THEY ARE INITIATED.  AS PART OF 
     THIS EFFORT, CERTAIN NETWORK PARAMETERS (EG., INVOCATION 
     NUMBER) ARE UPDATED AND GENERAL PARAMETER SUBSTITUTIONS MAY
     BE PERFORMED ON THE JOB CONTROL STATEMENTS PRIOR TO THE JOBS 
     BEING SUBMITTED TO THE INPUT QUEUE.
  
     THE JOB CONTROL STATEMENT SKELETONS ARE PREPARED AND MAINTAINED
     ON A MASTER FILE.  THE MASTER FILE NAME AND USER NUMBER ARE
     SELECTABLE/CHANGEABLE BY THE USER (MFN AND UN PARAMETERS), 
     ASSUMING THE USER HAS PERMITTED THE MASTER FILE TO SYSTEMX. THE
     MASTER FILE CONTAINS BOTH JOB SKELETONS (WHICH IN THEIR
     UPDATED FORM ARE SELECTABLY SENT TO THE INPUT QUEUE) AND PARAM-
     ETER RECORDS (WHICH CONTAIN THE KEYWORD-VALUE SUBSTITUTION 
     PAIRS FOR UPDATING THE JOB SKELETONS).  THE PARAMETER
     RECORDS ALSO CONTAIN THE NAMES OF THE JOB SKELETONS TO BE USED 
     DURING PROCESSING.  IN THIS WAY, ONE SET OF JOB SKELETONS MAY
     BE USED IN VARIOUS COMBINATIONS BY DIFFERENT PARAMETER RECORDS 
     TO INITIATE, RESTART OR PARTIALLY RESTART THE NETWORK. 
  
     THE OPERATION OF NAMI IS LOGICALLY STRAIGHT-FORWARD.  FOLLOWING
     OPERATOR INITIATION OF NAMI, ANY ENTERED PARAMETERS ARE
     PROCESSED (THEY MAY AFFECT MASTER FILE SELECTION) AND THE
     MASTER FILE IS ACCESSED.  THE MASTER FILE IS READ AND A TABLE
     OF PARAMETER RECORD NAMES AND JOB RECORD NAMES IS BUILT. 
     NEXT, THE SELECTED PARAMETER RECORD IS READ.  TWO LISTS
     ARE CONTSTRUCTED FROM THE PARAMETER RECORD-- A LIST OF JOBS
     TO BE LOADED AND A KEYWORD-VALUES REPLACEMENT PAIR LIST
     FOR UPDATING THE SELECTED JOB RECORDS. 
  
     THE MASTER FILE IS THEN READ (AGAIN) AND THE SELECTED JOB
     RECORDS ARE READ THE THE REQUIRED KEYWORD-VALUE SUBSTITUTIONS
     ARE MADE.  A LOCAL FILE VERSION OF THE JOB RECORD IS CREATED.
     WHEN ALL OF THE JOBS HAVE BEEN CREATED, THEY ARE ROUTED TO 
     THE INPUT QUEUE, ONE RIGHT AFTER THE OTHER.  FINALLY, IF 
     NIP IS ONE OF THE JOBS SELECTED, CONTROL IS PASSED DIRECTLY
     TO THE NIP CONTROL RECORD, OTHERWISE, NAMI IS TERMINATED.
  
     NAMI IS PRIMARILY INTENDED FOR USE AT THE CYBER CONSOLE. 
     HOWEVER, NAMI MAY BE EXERCISED INTERACTIVELY BY SPECIFYING 
     =TEST= AS ONE OF THE PARAMETERS ON THE CALL STATEMENT.  FOR
     EXAMPLE--- 
       NAMI,TEST,RN=RESTRT,MFN=MYMSTR,UN=BAR1234. 
     RUNNING NAMI REQUIRES SYSTEM ORIGIN PRIVILEGES 
     (*SYOT* OR *CSOJ* VALIDATION WITH *DEBUG*) 
  
  
# 
  CONTROL EJECT;
# 
     ILLEGAL KEYWORDS AND ERRONEOUSLY UNEQUIVALENCED KEYWORDS 
     ARE DIAGNOSED.  AN ERROR MESSAGE IS WRITTEN TO THE DAYFILE 
     AND THE *GO* PARAMETER, IF SPECIFIED, IS IGNORED.  NAMI
     WILL WAIT FOR ANOTHER CFO COMMAND. 
  
     IF THE NUMBER OF KEYWORDS IS CHANGED, THE VALUE OF 
     *NUMKWDS* MUST BE UPDATED AS WELL AS THE ARRAY *KWARRY*, 
     THE SWITCH *KEYWORD* AND ITS USE IN PROCS CRACK$CALL 
     AND NEWBASE, AND THIS LIST.
  
     LEGAL KEYWORDS ARE 
  
          GO
          MFN = MASTER FILE NAME
          OIN = OLD INVOCATION NUMBER 
          OPTION = SELECTED OPTION
          PW = PASSWORD 
          RN = RECORD NAME
          RS = RECORD NAME TO RESTART 
          TEST
          STOP
          TERM
          UN = USER NUMBER
# 
  CONTROL EJECT;
# 
                          NAMI MAIN PROCESSOR 
  
  
                P R O C E D U R E    C O N T E N T S
                ------------------------------------
  
  
                          ITEM DECLARATIONS 
                          LINK DECLARATIONS 
                          ARRAY DECLARATIONS
                          COMMON DECLARATIONS 
                          COMMON DECLARATIONS 
                          MISC DECLARATIONS 
                           FUNC KEYLINE 
                           PROC CLEAR$PW
                           PROC READ$CFO
                           PROC SHOTERM 
                           PROC CLR$OPMSG 
                           PROC WEEKDAY 
                           PROC INITCPA 
                           PROC DS$DEFAULT
                           PROC SETUP$NAMI
                           PROC DFL$RCDS
                           PROC GET$NXT$OP
                           PROC ROUT$FILES
                           PROC FILL55
                           PROC PRELOAD 
                           PROC INTRACT 
                           PROC EXTRACT 
                           PROC FIND$JOB
                           PROC CLRTABLE
                           PROC NEWBASE 
                           PROC DSPLAY$LIN
                           PROC SELJOB$LOD
                           PROC SELJOB$SAVE 
                           PROC SELJOB$ROUTE
                           PROC RLOD$DISP 
                           PROC GNXT$CCL
                           PROC SCAN$CCLS 
                           PROC LOAD$JOB
                           PROC SAVE$JOB
                           PROC SELJOB$MODFY
                           PROC OPTIONLOOP
                           PROC NAMIN (MAIN PROCESS)
  
  
  
        NAMI  COPYRIGHT CONTROL DATA SYSTEMS INC. 1994. 
  
  
# 
 
  CONTROL EJECT;
 
                                                  #ITEM DECLARATIONS   #
 
  BEGIN 
 
 
    ITEM STATS      U;                   # STATUS USED IN READ MACROS  #
    ITEM I          I;
    ITEM RECORDTYPE C(10);
    ITEM INDX1      I=0;
    ITEM INDX2      I=0;
    ITEM INDX3      I=0;
    ITEM INDXC      I=0;
    ITEM INDXR      I=-1; 
    ITEM UPIX       I=-1; 
    ITEM MODFYNDX   I=0;
    ITEM WORDCNT    I=3;
    ITEM TBLPTR     I=0;
    ITEM SKPLNS     I=0;
    ITEM JOBINDX    I=0;
    ITEM CTLRCDS    I=0;
    ITEM RUNRCDS    I=0;
    ITEM NXT2LOD    I=0;
    ITEM ABTCODE    I=0;
    ITEM K          I=0;
    ITEM J1         I=0,    J2      I=0,     J3      I=0; 
    ITEM N          I=0,    N1      I=0,     N2      I=0; 
    ITEM NR1        R=0,    NR2     R=0;
 
    ITEM SPACES     C(10) = "          "; 
    ITEM EDITX      C(10);
    ITEM SCANK      C(10);
    ITEM SCANV      C(10);
    ITEM CALL$OIN   C(10);
    ITEM JOBNAME    C(10) = "          "; 
    ITEM SUBSYSNAM  C(10) = "          "; 
    ITEM JOBOT      U;
    ITEM JOBSC      U;
    ITEM PAKWPTR    U;
    ITEM LIN4SCAN   C(180); 
 
    ITEM DISEND     B=TRUE; 
    ITEM FIRST      B=TRUE; 
    ITEM RT$IMMED   B=FALSE;
    ITEM CTLJOB     B=FALSE;
    ITEM RUNJOB     B=FALSE;
    ITEM NEED$OPRES B=TRUE; 
    ITEM RDY$2$ROUT B=FALSE;
    ITEM RDY$4$ROUT B=FALSE;
    ITEM DSPLYMODE  B=TRUE; 
    ITEM TESTING    B=FALSE;
    ITEM AUTO$GO    B=FALSE;
    ITEM START$SUBS B=FALSE;
    ITEM UPCFLAG    B=FALSE;
    ITEM INV$INCR   B=FALSE;
    ITEM NET$START  B=FALSE;
    ITEM DISDFLT    B=FALSE;
    ITEM RNCHANGED  B=FALSE;             # TRUE IF NEW RN IS SPECIFIED #
    ITEM RNKEYWORD  C(10);               # TEMPORARY FOR RN KEYWORD    #
    ITEM RNVALUE    C(10);               # NEW RN VALUE WHEN SPECIFIED #
    ITEM LASTENTRY  I=0;               # LAST ENTRY OF DIRECTORY TABLE #
    ITEM FOUND      B;                   # TEMPORARY BOOLEAN           #
 
  CONTROL EJECT;
                                                  #LINK DECLARATIONS   #
    XREF PROC READSKP;
    XREF PROC READH;
    XREF PROC RECALL; 
    XREF PROC ABTRUN; 
    XREF PROC CFOWAIT;
    XREF PROC CFOBCLR;
    XREF PROC CFOBSET;
    XREF PROC CHEKORG;
    XREF PROC FINSHIO;
    XREF PROC GETLINE;
    XREF PROC GNETCCL;
    XREF PROC NEWMAST;
    XREF PROC OFLUSH; 
    XREF PROC PRLDNIN;
    XREF PROC PUTRTO; 
    XREF PROC PUTRTR; 
    XREF PROC PUTRTC; 
    XREF PROC PUTRTL; 
    XREF PROC PUTLINE;
    XREF PROC PUTTERM;
    XREF PROC PUTTRMX;
    XREF PROC ROUTEM; 
    XREF PROC SENDMSG;
    XREF PROC SETNUN; 
    XREF PROC SETUPC; 
    XREF PROC SETUPC2;
    XREF PROC SIERRA; 
    XREF PROC STARTIO;
    XREF PROC TERMRD; 
    XREF PROC UPD8NIN;
    XREF PROC UPD8MFN;
 
    XREF FUNC XCDD       C(10); 
    XREF FUNC XCOD       C(10); 
    XREF FUNC XSFW       C(10); 
    XREF FUNC XCFD       C(10); 
    XREF FUNC STRIPSP    C(10); 
 
 
 
 
  COMMON IDINFO;
      BEGIN 
        ITEM IDVERSN    C(40);   # NAMI DATE/TIME/VERSION STAMP # 
        ITEM COPYRIGHT  C(50);   # NAMI COPYRIGHT               # 
      END 
  CONTROL EJECT;
# 
 *
 *  NAMI
 *
 *        CALLED FROM,LOADER
 *
 *        NAMI ENTRY POINT FOR PRIMARY PROCESS. 
 *
 *
 *   XREF PROC CFOWAIT
 *
 *        CALLED FROM READ$CFO, ROUT$FILES
 *
 *        WAIT FOR RA+0 CFO FLAG BIT TO BE CLEARED.  THIS IS
 *        IS CALLED AFTER A MESSAGE HAS BEEN DISPLAYED TO THE 
 *        OPERATOR TO ENTER A CFO TYPE MESSAGE AND THE BIT HAS
 *        BEEN SET. 
 *
 *
 *   XREF PROC CFOBCLR
 *
 *        CALLED FROM *NOREF
 *
 *        THIS IS USED WHEN WE ARE SIMULATING CONSOLE INPUT.  THE 
 *        ROUTINE IS CALLED TO CLEAR THE CFO FLAG BIT.
 *
 *
 *   XREF PROC CFOBSET
 *
 *        CALLED FROM READ$CFO, ROUT$FILES
 *
 *        THIS ROUTINE USED TO SET THE CFO FLAG BIT AFTER ASKING
 *        THE OPERATOR TO ENTER A CFO MESSAGE.  THE OPERATING 
 *        SYSTEM WILL CLEAR THE BIT WHEN THE CFO MESSAGE HAS BEEN 
 *        ENTERED AND POSTED IN THE JOB CONTROL AREA. 
 *
 *
 *   XREF PROC CHEKORG
 *
 *        CALLED FROM NAMI
 *
 *        ABORT IF NOT SYOT OR CSOJ IN DEBUG. 
 *
 *
 *   XREF PROC FINSHIO
 *
 *        CALLED FROM *NOREF
 *
 *        CLOSE CCL INPUT FILE (LFN=INFIL), TRACE FILE
 *        (LFN=OUTFIL) AND OUTPUT FILE.  CALLED AT END
 *        OF JOB. 
 *
# 
  CONTROL EJECT;
# 
 *
 *   XREF PROC GETLINE
 *
 *        CALLED FROM FIND$JOB, LOAD$JOB
 *
 *        READ ONE LINE OF DATA FROM THE NETWORK CCL FILE (LFN= 
 *        INFIL).  THE DATA IS RETURNED BASED UPON THE SETTING
 *        OF THE VARIABLE IOFWA.
 *
 *
 *   XREF PROC GNETCCL
 *
 *        CALLED FROM PRELOAD, FIND$JOB 
 *
 *        GET AND OPEN THE NETWORK CCL FILE (LFN=INFIL).  THE 
 *        FILE NAME AND USER NUMBER IS PASSED IN COMMON BLOCK 
 *        NETCTRL.
 *
 *
 *   XREF PROC NEWMAST
 *
 *        CALLED FROM NEWBASE 
 *
 *        INSTALL THE DEFAULT PARAMETERS INTO THE NEW NETWORK 
 *        (MASTER) CCL FILE.
 *
 *
 *   XREF PROC OFLUSH 
 *
 *        CALLED FROM NAMIN 
 *
 *        ISSUE A WRITER TO LFN=OUTFIL.  THIS FLUSHES THE TERMINAL
 *        OUTPUT BUFFER AND IS USED PRIMARILY FOR TESTING.
 *
 *
 *   XREF PROC PRLDNIN
 *
 *        CALLED FROM PRELOAD, LOAD$JOB 
 *
 *        PRELOAD THE NETWORK INVOCATION NUMBER.  THIS PLACES THE 
 *        THE NEW NIN INTO THE DEFAULT FILE NAMES.
 *
 *
 *   XREF PROC PUTRTO 
 *
 *        CALLED FROM SAVE$JOB
 *
 *        OPEN THE ROUTE FILE FOR THE JOB TO BE LOADED AND SENT 
 *        TO THE INPUT QUEUE. 
 *
# 
  CONTROL EJECT;
# 
 *
 *   XREF PROC PUTRTR 
 *
 *        CALLED FROM SAVE$JOB
 *
 *        WRITE AN END OF RECORD ON THE JOB ROUTE FILE. 
 *
 *
 *   XREF PROC PUTRTC 
 *
 *        CALLED FROM SAVE$JOB
 *
 *        ISSUE A WRITER ON THE ROUTE FILE AND CLOSE THE
 *        FILE. 
 *        THE FILE IS NOT RETURNED, BUT REMAINS LOCAL AT THIS 
 *        CONTROL POINT.
 *
 *
 *   XREF PROC PUTRTL 
 *
 *        CALLED FROM SAVE$JOB
 *
 *        WRITE A SINGLE LINE TO THE ROUTE FILE.  THIS IS A 
 *        WRITEH COMMAND AND STRIPS OFF TRAILING BLANKS.
 *
 *
 *   XREF PROC PUTLINE
 *
 *        CALLED FROM READ$CFO
 *
 *        WRITE A SINGLE LINE TO THE TRACE FILE.  THIS ALSO 
 *        IS A WRITEH FUNCTION. 
 *
 *
 *   XREF PROC PUTTERM
 *
 *        CALLED FROM SHOTERM 
 *
 *        WRITE A SINGLE LINE (WRITEH) TO THE OUTPUT FILE.
 *
 *
 *   XREF PROC PUTTRMX
 *
 *        CALLED FROM SHOTERM 
 *
 *        ISSUE A WRITER TO THE OUTPUT FILE TO FLUSH THE
 *        BUFFER.  THIS IS NECESSARY WHEN TESTING AT A TERMINAL 
 *        TO INSURE THAT THE ENTIRE MESSAGE GETS TO THE OPERATOR. 
 *
# 
  CONTROL EJECT;
# 
 *
 *   XREF PROC READLN 
 *
 *        CALLED FROM READ$CFO
 *
 *        READ ONE LINE OF INPUT FROM TERMINAL INPUT.   THIS IS USED
 *        DURING TESTING.  SEE PROC READ$CFO. 
 *
 *
 *   XREF PROC ROUTEM 
 *
 *        CALLED FROM ROUT$FILES
 *
 *        ROUTE THE FILE SPECIFIED IN COMMON AREA ROUTCOM TO THE QUEUE
 *        ALSO SPECIFIED IN ROUTCOM.  USED PRIMARILY TO ROUTE FILES TO
 *        THE INPUT QUEUE.
 *
 *
 *   XREF PROC SENDMSG
 *
 *        CALLED FROM READ$CFO, SETUP$NAMI, DFL$RCDS, SELJOB$LOD, NAMIN 
 *
 *        SEND THE MESSAGE IN COMMON AREA MSGCOM TO THE OPERATOR AND
 *        DAYFILE (A AND B DISPLAYS). 
 *
 *
 *   XREF PROC SETNUN 
 *
 *        CALLED FROM SETUP$NAMI
 *
 *        SET NAMI USER NUMBER
 *
 *
 *   XREF PROC SIERRA 
 *
 *        CALLED FROM INITCPA 
 *
 *        SIERRA IS A GROUP (CLUB) OF SYSTEM REQUESTS USED TO DETERMINE 
 *        THE ENVIRONMENT (DATE, TIME, CM FL).  THE INFORMATION IS
 *        RETURNED IN COMMON AREA SIERRAC.  SEE THE ERS FOR AN IMPACT 
 *        STUDY.
# 
  CONTROL EJECT;
# 
 *
 *
 *   XREF PROC STARTIO
 *
 *        CALLED FROM *NOREF
 *
 *        STARTIO GETS THE NETWORK CCL FILE (LFN=INFIL) AND OPENS IT. 
 *        IT ALSO OPENS THE TRACE AND TERMINAL OUTPUT FILE. 
 *
 *
 *   XREF PROC UPD8MFN
 *
 *        CALLED FROM NEWBASE, SELJOB$LOD, NAMIN
 *
 *        THIS ROUTINE UPDATES THE NETWORK MEMORY FILE WITH THE CURRENT 
 *        NETWORK INVOCATION NUMBER, NETWORK CCL FILE NAME AND DEFAULT
 *        (LAST USED) CONTROL RECORD NAME.
 *
 *
 *   XREF PROC UPD8NIN
 *
 *        CALLED FROM PRELOAD, FIND$JOB 
 *
 *        THE NETWORK INVOCATION NUMBER IS UPDATED- THIS RESULTS IN THE 
 *        VARIOUS DEFAULT FILE NAMES AND PARAMETER RECORDS BEGIN UPDATED. 
 *
 *
 *   XREF FUNC XCDD       C(10) 
 *
 *        CALLED FROM INITCPA, DSPLAY$LIN 
 *
 *        THIS IS A CONVERSION ROUTINE - INTEGER TO DECIMAL DISPLAY CODE. 
 *
 *
 *   XREF FUNC XCOD       C(10) 
 *
 *        CALLED FROM INITCPA, DS$DEFAULT, ROUT$FILES 
 *
 *        THIS IS A CONVERSION ROUTINE - INTEGER TO OCTAL DISPLAY CODE. 
 *
 *
 *   XREF FUNC XSFW       C(10) 
 *
 *        CALLED FROM DS$DEFAULT, ROUT$FILES, INTRACT, FIND$JOB,
 *                    LOAD$JOB
 *
 *        THIS IS A CONVERSION ROUTINE - SPACE FILL A WORD ENDING IN 00B. 
 *
# 
  CONTROL EJECT;
                                                  #ARRAY DECLARATIONS  #
 
    ARRAY LINE[0:10] S(1);
          BEGIN 
          ITEM LIN6       C(0, 0,    6);
          ITEM LINX       C(0, 0,   10);
          ITEM LIN80      C(0, 0,   80);
          ITEM LINX1A     C(0, 0,  110);
          ITEM LIN4       C(0, 0,    4);
          END 
 
    ARRAY ONELINE[0:0] S(10); 
          BEGIN 
          ITEM LIN$4      C(00,00,04);
          ITEM LIN$6      C(00,00,06);
          ITEM LIN$10     C(00,00,10);
          ITEM LIN$100    C(00,00,100); 
          END 
 
 
 
    ARRAY ENVIRONS [0:0] S(20); 
          BEGIN 
          ITEM ENV1       C(0,  0,  10) = ["          "]; 
          ITEM ENV2       C(1,  0,  10) = ["CFO=YES   "]; 
          ITEM ENV3       C(2,  0,  10) = ["CMU=YES   "]; 
          ITEM ENV4       C(3,  0,  10) = ["C/MEJ=YES "]; 
          ITEM ENV5       C(4,  0,  10) = ["          "]; 
          ITEM ENV6       C(5,  0,  10) = ["PPUS=00   "]; 
          ITEM ENV7       C(6,  0,  10) = ["CM=000000B"]; 
          ITEM ENV8       C(7,  0,  10) = ["          "]; 
          ITEM ENV9       C(8,  0,  20) = ["CONTROL STATEMENT = "]; 
          ITEM ENV10      C(08, 0,  50);
          ITEM ENV11      C(11, 0,  10);
          ITEM ENV12      C(12, 0,  10);
          ITEM ENV13      C(13, 0,  10) = ["          "]; 
          ITEM ENV14      C(14, 0,  10) = ["SUNDAY    "]; 
          ITEM ENV15      C(15, 0,  20) = [" MM/DD/YY  HH.MM.SS "]; 
          END 
 
 
    ARRAY DIR$TABLE [0:200] S(1); 
          BEGIN 
          ITEM DIR$NAME   C(0, 0, 7); 
          ITEM PRU$ADDR   U(0, 42,12);    # NUMBER OF PRUS FROM BOI # 
          ITEM DIR$TYPE   U(0, 54, 6);
          END 
 
          DEF ZTYPE           #0#;
          DEF PTYPE           #1#;
          DEF JTYPE           #3#;
          DEF STAT$EOR        #O"000023"#;
          DEF STAT$EOF        #O"740033"#;
          DEF STAT$EOI        #O"741033"#;
 
    ARRAY REPLACE$TBL [0:200] S(3); 
          BEGIN 
            ITEM REPKEY     C(0, 0, 10);
            ITEM REPVAL     C(1, 0, 10);
            ITEM REPSIZ     U(2, 0, 60);
          END 
 
  CONTROL EJECT;
                                                  #COMMON DECLARATIONS #
    COMMON PASSIT;
      BEGIN 
      ITEM IOFWA      I;
      ITEM IOCNT      I;
      ITEM IOCMP      I;
      ITEM IOLVL      I;
      ITEM IOFLG      I;
      END 
 
    COMMON THEFET;
      BEGIN 
      ARRAY INFIL [0:0] S(15);
        BEGIN 
        ITEM FET$WORD0   U(00,00,60); 
        ITEM FET$LFN     C(00,00,07) =["INFIL  "];
        ITEM FET$STAT    U(00,42,18); 
        ITEM FET$WORD1   U(01,00,60); 
        ITEM FET$FIRST   U(01,42,18); 
        ITEM FET$RANDOM  U(01,12,01); 
        ITEM FET$WORD2   U(02,00,60); 
        ITEM FET$IN      U(02,42,18); 
        ITEM FET$WORD3   U(03,00,60); 
        ITEM FET$OUT     U(03,42,18); 
        ITEM FET$WORD4   U(04,00,60); 
        ITEM FET$LIMIT   U(04,42,18); 
        ITEM FET$WORD6   U(06,00,60); 
        ITEM FET$CRI     U(06,00,30);    # CURRENT RANDOM INDEX      #
        ITEM FET$RR      U(06,31,29);    # RANDOM REQUEST            #
        END 
      END 
 
    COMMON PARAMS;
        BEGIN 
        ITEM CMODE      I;
        ITEM CSTAT      I;
        ARRAY CMSG     [0:7] S(1);
              BEGIN 
              ITEM CMESS      C(0, 0, 10);
              ITEM CMSG80     C(0, 0, 80);
              END 
        END 
 
    COMMON NETCOM;
        BEGIN 
      ARRAY NETCOMA     [0:27]  S(1); 
              BEGIN 
                ITEM NETINVN    C(0, 0, 10);
                ITEM NETINCR    U(1, 0, 60);
                ITEM NCOM80     C(2, 0, 180); 
                ITEM NCOM80A    C(17,0, 80);
              END 
        END 
 
    COMMON UPAR;
        BEGIN 
        ARRAY UPARMS [0:40] S(8); 
              BEGIN 
                ITEM UPARAM     C(0, 0, 80);
              END 
        END 
 
    COMMON PACKING; 
        BEGIN 
        ITEM PACK80     C(80);
        ITEM PACK160    C(100); 
        ITEM PACKEND    C(10);
        ARRAY PACK01    [0:79] S(1);
              BEGIN 
              ITEM PACKW      C(0, 0, 10);
              ITEM PACKZW     U(0, 0, 60);
              ITEM PACKWE     C(0,54, 01);
              END 
        ITEM UPCSTAT    U;
        ITEM UPCOUNT    U;
        END 
  CONTROL EJECT;
                                                  #COMMON DECLARATIONS #
 
    COMMON ROUTCOM; 
        BEGIN 
        ITEM ROUTNAM    C(10);
        ITEM ROUTCOD    I;
        ITEM ROUTYPE    I;
        ITEM RTEOT      U;
        ITEM RTESC      U;
        END 
 
        DEF  ROUTIQ     #0#;
        DEF  ROUTOQ     #1#;
        DEF  ROUTSS     #O"0400"#;
        DEF  ROUTNIP    #O"1000"#;
        DEF  ROUTSYOT   #O"4000"#;
 
    COMMON SIERRAC; 
      BEGIN 
       ARRAY SIE [0:0] S(7);
             BEGIN
             ITEM SIECM      U(0, 00, 30);
             ITEM SIEDATE    C(1, 00, 10);
             ITEM SIEJDATE   C(2, 00, 10);
             ITEM SIEJYR     C(2, 30, 02);
             ITEM SIEJDAY    C(2, 42, 03);
             ITEM SIETIME    C(3, 00, 10);
             ITEM SIECPUS    U(4, 24, 24);
             ITEM SIECPUMS   U(4, 48, 12);
             ITEM SIEUSER    C(5, 00, 07);
             ITEM SIEMID     C(6, 00, 10);
             END
      END 
 
    COMMON PFEMSG;
      BEGIN 
        ITEM PFERMSG    C(40);
      END 
 
    COMMON ROUTABL; 
      BEGIN 
        ARRAY RTFT [0:200] S(1);
              BEGIN 
                ITEM RTFN       C(0, 00, 8);
                ITEM RTFNOT     U(0, 48, 3);
                ITEM RTFNSC     U(0, 51, 3);
                ITEM RTFNCD     U(0, 54, 6);
              END 
      END 
 
  COMMON MSGCOM;
      BEGIN 
      ARRAY MSGCOMA [0:8] S(1); 
            BEGIN 
              ITEM OPMSG1    C(0, 00, 10);
              ITEM OPMSG     C(0, 00, 80);
              ITEM OPMSGZB   U(0, 00, 60);
            END 
      END 
  CONTROL EJECT;
 
 
  COMMON NETCTRL; 
      BEGIN 
      ARRAY NETMASTR [0:63] S(1); 
          BEGIN 
            ITEM NETMSTR    C(00,00,200); 
            ITEM MSTRMFN    C(21,00,07);
            ITEM MSTRUN     C(23,00,07);
            ITEM MSTRPW     C(25,00,07);
            ITEM MSTRFM     C(27,00,07);
            ITEM MSTRRN     C(29,00,10);
            ITEM MSTRUNM    C(23,00,07);
            ITEM MSTRPWM    C(25,00,07);
            ITEM MSTRLIN    C(31,00,03);
            ITEM MSTRUIN    C(33,00,03);
            ITEM MSTRMEMUN  C(35,00,07);
            ITEM MSTROIN    C(37,00,03);
            ITEM MSTRMACHID C(39,00,10);
            ITEM MSTRRS     C(41,00,07);
          END 
      END 
 
    COMMON TBLADR;
        BEGIN 
        ARRAY TABLAD [0:6] S(1);
              BEGIN 
              ITEM TADR        U(0, 0,  30);
              ITEM TLEN        U(0, 30, 30);
              END 
        END 
 
    COMMON TERMCOM; 
        BEGIN 
        ITEM TERMRDLN   I;
        ITEM TERMRDBFR  C(240); 
        ITEM TERMRDB2   C(240); 
        ITEM TERMRDB3   C(170); 
        END 
 
  COMMON RESTART; 
      BEGIN 
      ITEM RESTRT B = FALSE;  # RESTART APPLICATION FLAG               #
      ITEM RSAPPL C(7);  # APPLICATION TO RESTART                      #
      ITEM JOBDI B;   # FLAG - DI SPECIFIED ON JOB STATEMENT           #
      ITEM APFOUND B;  # APPL JOB RECORD FOUND FLAG                    #
      ITEM JOBFOUND B;  # JOB FOUND FLAG                               #
      ITEM DONE B;  # COMPLETION FLAG                                  #
      ITEM JBNAME C(10);  # JOB NAME                                   #
      END 
 
  CONTROL EJECT;
                                                  #MISC DECLARATIONS   #
 
    ITEM OPTION     I=0;
         DEF OPTDISP    #1#;
         DEF OPTLOAD    #2#;
         DEF OPTMOD     #3#;
         DEF OPTSAVE    #4#;
         DEF OPTSBMT    #5#;
         DEF OPTTERM    #6#;
         DEF OPTROUT    #7#;
 
    DEF DISPOPT    #0#; 
    DEF DISPJBS    #1#; 
    DEF DISPCCB    #2#; 
    DEF DISPZRO    #5#; 
 
    DEF EOR        #O"1"#;
    DEF EOF        #O"3"#;
    DEF EOI        #O"3"#;
 
 
  ARRAY JOBLISTS [0:200] S(3);
        BEGIN 
        ITEM JBL1       C(0, 0, 10);     # JOB NAME # 
        ITEM JBL2       C(1, 0, 10);     # ROUTE FILE NAME #
        ITEM JBL3       C(2, 0,  9);                  # SUBSYSTEM NAME #
        ITEM JBL3OT     U(2,54,  3);                  # ORIGIN TYPE    #
        ITEM JBL3SC     U(2,57,  3);                  # SERVICE CLASS  #
        END 
 
  # CALL STATEMENT KEYWORDS                                            #
 
  DEF NUMKWDS  #11#;               #NUMBER LEGAL KEYWORDS              #
 
  ARRAY KWARRY [1:NUMKWDS] S(1);   #CORRESPONDS TO SWITCH KEYWORD      #
    BEGIN 
    ITEM KWORD C(0,0,10) =
         ["GO        ", 
          "MFN       ", 
          "OIN       ", 
          "OPTION    ", 
          "PW        ", 
          "RN        ", 
          "RS        ", 
          "STOP      ", 
          "TERM      ", 
          "TEST      ", 
          "UN        "];
    END 
  CONTROL EJECT;
 
    BASED 
    ARRAY MSGTBL [0:99] S(1); 
          BEGIN 
          ITEM CHLOW      C(0, 48,  2); 
          ITEM CHX        C(0,  0, 10); 
          ITEM CWC        U(0,  0,  6); 
          ITEM CZZ        C(0,  0, 70); 
          END 
 
    XREF
    ARRAY RAZERO [0:0] S(64); 
          BEGIN 
          ITEM JCACFO     B(00, 45, 01);
          ITEM JCACMU     B(53, 00, 01);
          ITEM JCACME     B(54, 00, 01);
          ITEM JCAPPU     U(54, 07, 05);
          ITEM JCA70      C(56, 00, 30);
          ITEM JCAOPMSG   C(56, 00, 80);
          END 
 
    ARRAY CCLBUFR [0:300] S(8); 
          BEGIN 
          ITEM CCLE       C(0, 0, 80);
          ITEM CCL01      C(0, 0, 01);
          ITEM CCL04      C(0, 0, 04);
          END 
 
    ARRAY DATALNX [0:0] S(9); 
          BEGIN 
          ITEM DLX1       C(0, 0,  1) = [" "];
          ITEM DLNUM1     C(0, 6,  3);
          ITEM DLX2       C(0, 24, 1) = ["."];
          ITEM DLNUM2     C(0, 30, 3);
          ITEM DLX3       C(0, 48, 2) = ["= "]; 
          ITEM DATALN     C(1, 0, 80);
          END 
 
    ARRAY DATALNY [0:0] S(12);
          BEGIN 
          ITEM LNY0       C(0, 0, 20) = ["          MODE = 00B"]; 
          ITEM LNY1       C(2, 0, 20) = ["        OPTION = 00B"]; 
          ITEM LNY2       C(4, 0, 20) = ["          MID =   --"]; 
          ITEM LNY3       C(6, 0, 20) = ["          CIN = 000D"]; 
          ITEM LNY4       C(8, 0, 20) = ["        OIN = 000D "];
          ITEM LNY5       C(10,0, 20) = ["          UIN = 000D"]; 
          ITEM LNY1A      C(1, 42, 2);
          ITEM LNY1B      C(3, 42, 2);
          ITEM LNY1C      C(5, 48, 2);
          ITEM LNY1D      C(7, 36, 3);
          ITEM LNY1E      C(9, 24, 3);
          ITEM LNY1F      C(11,36, 3);
          ITEM LNY        C(0, 30, 55); 
          ITEM LNYA       C(6, 30, 55); 
          END 
  CONTROL EJECT;
 
    ARRAY DATALNZ [0:0] S(14);
          BEGIN 
          ITEM LNZ0       C(0, 0, 20) = ["          RN = LSTPR"]; 
          ITEM LNZ1       C(2, 0, 20) = ["CD      MFN = NETCTR"]; 
          ITEM LNZ2       C(4, 0, 20) = ["L         UN = BAR12"]; 
          ITEM LNZ3       C(6, 0, 10) = ["34        "]; 
          ITEM LNZ4       C(7, 0, 20) = ["          UN  = XXXX"]; 
          ITEM LNZ5       C(9, 0, 20) = ["XXX     FM = (N/A)  "]; 
          ITEM LNZ6       C(11,0, 20) = ["          PW  = YYYY"]; 
          ITEM LNZ7       C(13,0, 10) = ["YYY       "]; 
          ITEM LNZ4A      C(8, 36, 7);
          ITEM LNZ4B      C(10, 18, 7); 
          ITEM LNZ4C      C(12, 36, 7); 
          ITEM LNZ1A      C(1, 30, 7);
          ITEM LNZ1B      C(3, 24, 7);
          ITEM LNZ1C      C(5, 30, 7);
          ITEM LNZ        C(0, 30, 65); 
          ITEM LNZ2ND     C(7, 30, 65); 
          END 
 
    ARRAY DAY2DAY [0:6] S(1); 
          BEGIN 
          ITEM DAY0       C(0, 0, 10) = ["SUNDAY    "]; 
          ITEM DAY1       C(1, 0, 20) = ["MONDAY    TUESDAY   "]; 
          ITEM DAY3       C(3, 0, 20) = ["WEDNESDAY THURSDAY  "]; 
          ITEM DAY5       C(5, 0, 20) = ["FRIDAY    SATURDAY  "]; 
          END 
 
    ARRAY DATALNR [0:0] S(5); 
          BEGIN 
          ITEM LNR0       C(0, 0, 20) = ["          NETWORK IN"]; 
          ITEM LNR2       C(2, 0, 20) = ["VOCATION NUMBER 000 "]; 
          ITEM LNR4       C(4, 0, 10) = ["          "]; 
          ITEM LNR2A      C(3, 36, 3);
          ITEM LNR        C(0, 0, 60);
          END 
  CONTROL EJECT;
 
    ARRAY DATALNW [0:0] S(3); 
          BEGIN 
          ITEM UPD8M0     C(0, 0,  10) = ["          "];
          ITEM UPD8MSG    C(1, 0,  20) = [" UPDATED BUFFER:    "];
          END 
 
    ARRAY DATALNV [0:0] S(4); 
          BEGIN 
          ITEM RSTM0      C(0, 0, 20) = ["          FILNAME RO"]; 
          ITEM RSTM1      C(2, 0, 20) = ["UTED, STAT = 0000B  "]; 
          ITEM RSTM2      C(3, 18, 4);
          ITEM RSTM3      C(1, 0, 7); 
          END 
 
    ARRAY DATALNU [0:0] S(4); 
          BEGIN 
          ITEM FSV0         C(0, 0, 20) = ["          FILE SAVED"]; 
          ITEM FSV1         C(2, 0, 20) = [" ON ROUTFIL         "]; 
          END 
 
    ARRAY DATALNT [0:0] S(4); 
          BEGIN 
          ITEM FLS0         C(0, 0, 20) = ["          FILNAME LO"]; 
          ITEM FLS1         C(2, 0, 20) = ["ADED, STAT = 0000B  "]; 
          ITEM FLS2         C(1, 0,  7);
          END 
 
    ARRAY DATALNS [0:0] S(4); 
          BEGIN 
          ITEM LDF0         C(0, 0, 20) = ["          LOADING   "]; 
          ITEM LDF1         C(2, 0, 20) = ["                    "]; 
          ITEM LDF2         C(2, 0,  7);
          ITEM LDF          C(0, 0, 40);
          END 
  CONTROL EJECT;
 
 
# 
 *  ABORT ROUTINES
# 
 
  PROC ABORTRUN (ABTCD);
 
  BEGIN 
 
    ITEM ABTCD     I; 
 
    ABTCODE = ABTCD;
 
    CLR$OPMSG;
    IF ABTCODE EQ 0 THEN
       OPMSG[0] = " NAMI ABORT CODE 0"; 
    IF ABTCODE EQ 1 THEN
       OPMSG[0] = " JOB/PARAM RECORD COUNT EXCEEDS 200";
    IF ABTCODE EQ 2 THEN
       OPMSG[0] = " JOB STATEMENTS IN PARAM RECORD EXCEED 200"; 
    IF ABTCODE EQ 3 THEN
       OPMSG[0] = " PARAM STATEMENTS IN PARAM RECORD EXCEED 40";
    IF ABTCODE EQ 4 THEN
       OPMSG[0] = " KEYWORD/VALUE COUNT IN PARAM RECORD EXCEEDS 200"; 
    IF ABTCODE EQ 5 THEN
       OPMSG[0] = " TOTAL KEYWORD/VALUE COUNT EXCEEDS 200"; 
    IF ABTCODE EQ 101 THEN
       OPMSG[0] = " INVALID PARAMETER(S) IN JOB STATEMENT"; 
    IF ABTCODE EQ 102 THEN
       OPMSG[0] = " OT, IF SPECIFIED, MUST BE SY OR BC";
    IF ABTCODE EQ 103 THEN
       OPMSG[0] = " SC, IF SPECIFIED, MUST BE SY, NS, OR BC"; 
    IF ABTCODE EQ 104 THEN
       OPMSG[0] = " SC, IF SPECIFIED, MUST BE BC IF OT=BC"; 
 
    OPMSGZB[7] = 0; 
    SHOTERM (LOC(OPMSG[0]), 8, TRUE); 
    SENDMSG;
    IF ABTCODE GQ 100 
       THEN BEGIN 
            CLR$OPMSG;
            FOR K = 0 STEP 1 WHILE C<K,1>PACK80 NQ C<0,1>PACKEND DO 
                C<K,1>OPMSG[0] = C<K,1>PACK80;
            OPMSGZB[7] = 0; 
            SHOTERM (LOC (OPMSG[0]),8,TRUE);
            SENDMSG;
            END 
    ABTRUN;     # ABORT EXIT...   NO RETURN#
 
  END   # ABORTRUN #
 
 
  CONTROL EJECT;
 
 
# 
 *
 *   FUNC KEYLINE 
 *
 *        CALLED FROM SELJOB$LOD, RLOD$DISP 
 *
 *        THE LINE BUFFER (CONTAINING THE CURRENT OPERATOR ENTERED OR 
 *        DEFAULT PARAMETER RECORD) IS SCANNED TO DETERMINE IF THERE
 *        ARE ANY KEY=VAL PAIRS FOR RECORD MODIFICATION.  WE ARE JUST 
 *        LOOKING FOR AN EQUAL SIGN (=).
 *
# 
  FUNC KEYLINE B; 
 
  BEGIN 
 
    ITEM NX       I;
 
    KEYLINE = FALSE;
    FOR NX = 0 STEP 1 UNTIL 79 DO 
    BEGIN 
        IF C<NX,1>LIN80[0] EQ "=" THEN KEYLINE = TRUE;
        IF C<NX,1>LIN80[0] EQ "=" THEN RETURN;
        IF C<NX,1>LIN80[0] EQ " " THEN RETURN;
    END 
 
  END #KEYLINE# 
 
  CONTROL EJECT;
 
# 
 *   FUNC DCODE 
 *
 *        DCODE CONVERTS A TEN CHARACTER DISPLAY CODED
 *        FIELD TO AN DECIMAL INTEGER.  ONLY THE CHARACTERS 
 *        FROM 0 THROUGH 9 ARE CONVERTED. 
 *
# 
 
  FUNC DCODE (CHARS) I; 
 
  BEGIN 
 
    ITEM CHARS C(10); 
    ITEM TVAL I;
    ITEM J1   I;
 
    DCODE = 0;
    TVAL = 0; 
 
    FOR J1 = 0 STEP 1 UNTIL 9 DO
    BEGIN 
      IF (C<J1,1>CHARS GQ "0") AND (C<J1,1>CHARS LQ "9")
         THEN BEGIN 
              TVAL = TVAL * 10 + (C<J1,1>CHARS - "0");
              END 
    END 
 
    DCODE = TVAL; 
 
  END #DCODE# 
  CONTROL EJECT;
# 
 *   PROC CALC$OIN (CHARS, SUBTR) 
 *
 *        DECIMAL DISPLAY CODE NUMBER *CHARS* IS EXPANDED TO THREE
 *        DIGITS.  IF *SUBTR*, ONE IS SUBTRACTED FROM *CHARS*.  THE 
 *        NEW NUMBER IS STORED IN MSTROIN.
# 
 
  PROC CALC$OIN (CHARS,SUBTR);
 
  BEGIN 
 
    ITEM CHARS      C(10);
    ITEM SUBTR      B;
 
    ITEM VAL1       I;
 
    VAL1 = DCODE (CHARS); 
    IF SUBTR THEN VAL1 = VAL1 - 1;
    IF VAL1 LS 0 THEN VAL1 = 999; 
    VAL1 = VAL1 + 10000;
    EDITX = XCDD (VAL1);
    C<0,3>MSTROIN[0] = C<7,3>EDITX; 
 
  END #CALC$OIN#
  CONTROL EJECT;
# 
 *   PROC CLEAR$PW
 *
 *        CALLED FROM READ$CFO, NAMI
 *
 *        SEARCH BUFFER MSGCOMA FOR THE STRING *PW=*.  IF FOUND,
 *        THEN THE PASSWORD IS DELETED. 
 *        UP TO 7 CHARACTERS ARE CLEARED, OR UNTIL A NON ALPHA- 
 *        NUMERIC CHARACTER IS ENCOUNTERED.  THE BUFFER IS
 *        EXPECTED TO BE 8 WORDS LONG OR TERMINATED WITH A
 *        ZERO WORD. ALL OCCURRENCES OF A PASSWORD ARE CLEARED. 
 *
# 
 
  PROC CLEAR$PW;
 
  BEGIN 
 
    ITEM CPCHR  I;                     #CURRENT CHAR TO READ           #
    ITEM CPPOS  I;                     #CURRENT CHAR POSITION TO WRITE #
    ITEM CPEND  I;                     #LAST CHARACTER IN STMT         #
    ITEM CP1    I;                     #LOOP INDEX                     #
 
    CPCHR = 0;
    CPPOS = 0;
 
    FOR CPEND = 0 WHILE                #DETERMINE END OF STATEMENT     #
        B<48,12>OPMSGZB[CPEND] NQ 0 
        AND CPEND LS 7  DO
      CPEND = CPEND + 1;               #WORD WITH ZERO BYTE TERM       #
    CPEND = CPEND*10 + 9;              #LAST POSSIBLE CHARACTER        #
 
    FOR CPCHR=0 WHILE CPCHR LQ CPEND DO 
      BEGIN  #STATEMENT LOOP #
      IF C<CPCHR,3>OPMSG[0] EQ "PW="              #KEYWORD FOUND       #
      THEN
        BEGIN  #IF  PW=  FOUND# 
        C<CPPOS,3>OPMSG[0] = C<CPCHR,3>OPMSG[0];  #WRITE  PW=          #
        CPPOS = CPPOS + 3;             #INCREMENT POINTERS PAST  PW=   #
        CPCHR = CPCHR + 3;
        FOR CP1=1 STEP 1 UNTIL 7 DO    #INCREMENT CPCHR TO AFTER PW    #
          BEGIN  #PASSWORD LOOP#
          IF C<CPCHR,1>OPMSG[0] GQ "A"
                AND C<CPCHR,1>OPMSG[0] LQ "9" 
          THEN
            CPCHR = CPCHR + 1;
          ELSE
            TEST CPCHR;                #RESUME MAIN LOOP AT END OF PW  #
 
          END  #PASSWORD LOOP#
 
        END  #IF  PW=  FOUND# 
      ELSE
        BEGIN  #NOT AT PW= #
        C<CPPOS,1>OPMSG[0] = C<CPCHR,1>OPMSG[0];  #WRITE THIS CHARACTER#
                                                  #TO NEXT POSITION.   #
        CPPOS = CPPOS + 1;             #INCREMENT POINTERS             #
        CPCHR = CPCHR + 1;
        END  #ELSE NOT AT PW= # 
 
      END  #MAIN LOOP#
 
      FOR CP1=CPPOS STEP 1 UNTIL CPEND DO    #ZERO REST OF BUFFER      #
        C<CP1,1>OPMSG[0] = 0; 
 
      RETURN; 
 
    END #PROC CLEAR$PW# 
  CONTROL EJECT;
 
 
# 
 *
 *   PROC READ$CFO
 *
 *        CALLED FROM GET$NXT$OP, SELJOB$LOD, SELJOB$MOD
 *
 *        THE MESSAGE BUFFER IS CLEARED.  IF WE ARE A CONSOLE JOB THEN
 *        WE ISSUE A MESSAGE TO THE B-DISPLAY AND WAIT FOR A CFO INPUT
 *        MESSAGE.  IF WE ARE TESTING (IE., USING A REMOTE TERMINAL AND 
 *        NOT AT THE CONSOLE) THEN ISSUE A MESSAGE TO THE TERMINAL
 *        AND WAIT FOR A RESPONSE.  IN ANY CASE, THE CFO FLAG BIT IN RA+0 
 *        IS SET AND CLEARED. 
 *
 *
 *        CALLS CFOBSET, READLN, CFOWAIT, PUTLINE, SENDMSG
 *
# 
 
  PROC READ$CFO;
 
  BEGIN 
 
    ITEM SAVEFWA    I;
 
    IF CSTAT EQ 2 THEN CMSG80[0] = " ENTER OPTION       ";
    IF CSTAT EQ 4 THEN CMSG80[0] = " ENTER CHANGES      ";
    SHOTERM (LOC(CMSG80[0]), 2, TRUE);
    FOR K = 0 STEP 1 UNTIL 7 DO 
        CMESS[K] = SPACES;
    CFOBSET;
    IF TESTING THEN 
       BEGIN
         CFOBCLR; 
         TERMRD;
         JCAOPMSG[0] = TERMRDBFR; 
         IF TERMRDLN EQ 0 THEN CSTAT = 0; 
                          ELSE CSTAT = CSTAT +1;
       END
    CFOWAIT;
    C<1,79>CMSG80[0] = JCAOPMSG[0]; 
    C<0,1>CMSG80[0] = " ";
    SAVEFWA = IOFWA;
    IOFWA = LOC(CMSG80[0]); 
    IOCNT = 7;
    PUTLINE;
    OPMSG[0] = CMSG80[0]; 
    OPMSGZB[8] = 0; 
    FOR K=0 WHILE K LQ 6 DO 
      IF B<54,6>OPMSGZB[K] EQ 0   #IF 0-BYTE TERMINATOR                #
      AND B<0,6>OPMSGZB[K+1] EQ 0   #SPLIT ACROSS WORD BOUNDARY        #
      THEN
        BEGIN 
        OPMSGZB[K+1] = 0;         #FORCE END OF MESSAGE                #
        K = 8;                    #TERMINATE LOOP                      #
        END 
      ELSE
        K = K + 1;
 
    SENDMSG;
    IOFWA = SAVEFWA;
    CMSG80[0] = JCAOPMSG[0];
    JCAOPMSG[0] = SPACES; 
 
  END   #READ CFO#
  CONTROL EJECT;
# 
 *
 *   PROC SHOTERM     (FWA, COUNT, FLUSH) 
 *
 *        CALLED FROM INITCPA, DS$DEFAULT, ROUT$FILES, DSPLA
 *                    SELJOB$LOD, SELJOB$SAV, SELJOB$MOD, OPTIONLOOP
 *
 *        THE MESSAGE STARTING AT FWA (IF FWA IS 0 THEN USE THE LAST
 *        FWA) CONSISTING OF COUNT NUMBER OF 10 CHARACTER WORDS IS SENT 
 *        TO THE TERMINAL OPERATOR (FILE LFN=OUTPUT).  IF FLUSH IS
 *        TRUE THEN WE ALSO ISSUE A WRITER TO THE OUTPUT FILE TO
 *        FLUSH THE BUFFER (USED AT THE END OF A SERIES OF MESSAGES). 
 *
 *        CALLS PUTTERM, PUTTRMX
 *
# 
 
    PROC SHOTERM (FWA, COUNT, FLUSH); 
 
    BEGIN 
 
      ITEM FWA I; 
      ITEM COUNT I; 
      ITEM FLUSH B; 
 
      IF FWA NQ 0 THEN IOFWA = FWA; 
      IF COUNT NQ 0 THEN IOCNT = COUNT; 
      IF TESTING THEN 
      BEGIN 
        PUTTERM;
        IF FLUSH THEN PUTTRMX;
      END 
 
    END #SHOTERM# 
 
 
 
# 
 *
 *   PROC CLR$OPMSG 
 *
 *        CALLED FROM SETUP$NAMI, DFL$RCDS, SELJOB$LOD, NAMIN 
 *
 *        CLEAR THE OPERATOR MESSAGE BUFFER - OPMSG.
 *
# 
 
  PROC CLR$OPMSG; 
  BEGIN 
    ITEM NN         I;
    FOR NN = 0 STEP 1 UNTIL 7 DO
        OPMSG1[NN] = SPACES;
  END      #CLR$OPMSG#
 
  CONTROL EJECT;
 
 
# 
 *
 *   PROC WEEKDAY 
 *
 *        CALLED FROM INITCPA 
 *
 *        GIVEN THE JULIAN DATE, THE DAY OF THE WEEK IS CALCULATED.  THIS 
 *        IS USED DURING INITIALIZATION TIME AS PART OF THE ENVIRONMENTAL 
 *        IMPACT PROCESSING.
 *
# 
 
    PROC WEEKDAY; 
 
    BEGIN 
 
      EDITX = SIEJYR; 
      N1 = C<0,1>EDITX - "0"; 
      N2 = C<1,1>EDITX - "0"; 
      N  = (N1 * 10) + N2;
      IF N LS 70 THEN N = N + 100;  # ADJUST FOR CENTURY               #
      NR1 = 365.25 * N; 
      EDITX = SIEJDAY;
      N1 =       (C<0,1>EDITX - "0") * 100; 
      N1 = N1 + ((C<1,1>EDITX - "0") * 10); 
      N1 = N1 +  (C<2,1>EDITX - "0"); 
      NR1 = NR1 + N1; 
      N = NR1;
      NR2 = N;
      IF NR1 EQ NR2 THEN NR1 = NR1 - 1.0; 
      N = NR1;
      FOR K=0 WHILE N GR 6 DO 
        N = N -7; 
      ENV14 = DAY0[N];
 
    END #WEEKDAY# 
 
  CONTROL EJECT;
 
# 
 *
 *   PROC INITCPA 
 *
 *        CALLED FROM SETUP$NAMI
 *
 *        VARIOUS VALUES IN THE JOB CONTROL AREA ARE EXAMINED AND DISPLAYED 
 *        TO THE OPERATOR.  THIS IS DONE DURING INITIALIZATION PROCESSING 
 *        FOR INFORMATIONAL PURPOSES ONLY.
 *
 *        CALLS SIERRA, WEEKDAY, SHOWTERM 
 *
# 
 
    PROC INITCPA; 
 
    BEGIN 
 
      SIERRA; 
 
      IF NOT JCACFO THEN C<4,3>ENV2 = "NO ";
      IF NOT JCACMU THEN C<4,3>ENV3 = "NO ";
      IF NOT JCACME THEN C<6,3>ENV4 = "NO ";
      N = JCAPPU; 
      EDITX = XCDD(N);
      C<5,2>ENV6 = C<8,2>EDITX; 
      N = SIECM;
      EDITX = XCOD(N);
      C<3,6>ENV7 = C<4,6>EDITX; 
      C<00,10>ENV15 = SIEDATE;
      C<10,10>ENV15 = SIETIME;
      WEEKDAY;
      SHOTERM (LOC(ENV1), 1, FALSE);
      SHOTERM (LOC(ENV1), 4, FALSE);
      SHOTERM (LOC(ENV5), 3, FALSE);
      SHOTERM (LOC(ENV8), 3, FALSE);
      ENV10 = JCAOPMSG; 
      JCAOPMSG[0] = SPACES; 
      FOR K = 0 STEP 1 UNTIL 29 DO
        IF C<K,1>ENV10 EQ 0 THEN C<K,1>ENV10 = " "; 
      SHOTERM (LOC(ENV8), 6, FALSE);
      SHOTERM (LOC(ENV13), 1, FALSE); 
      SHOTERM (LOC(ENV13), 4, FALSE); 
      SHOTERM (0, 1, TRUE); 
 
      NR1 = SIECPUS * 1000.0; 
      NR2 = SIECPUMS; 
      NR1 = NR1 + NR2;
 
    END #INITCPA# 
  CONTROL EJECT;
 
 
# 
 *
 *   PROC DS$DEFAULT
 *
 *        CALLED FROM NEWBASE, OPTIONLOOP 
 *
 *        THE CURRENT DEFAULT CONTROL VALUES ARE DISPLAYED TO THE OPERATOR. 
 *        THIS INCLUDES, BUT IS NOT LIMITED TO, THE CURRENT MASTER FILE 
 *        NAME, NETWORK INVOCATION NUMBER, AND CURRENT DEFAULT PARAMETER
 *        RECORD NAME.
 *
 *        CALLS SHOTERM, XCOD, XSFW 
 *
# 
 
  PROC DS$DEFAULT;
 
  BEGIN 
 
      EDITX = XCDD(DCODE(MSTRLIN[0]));
      C<0,3>MSTRLIN[0] = C<7,3>EDITX; 
      EDITX = XCDD(DCODE(MSTRUIN[0]));
      C<0,3>MSTRUIN[0] = C<7,3>EDITX; 
 
      EDITX = XCOD(CMODE);
      LNY1A = C<8,2>EDITX;
      EDITX = XCOD(OPTION); 
      LNY1B = C<8,2>EDITX;
      LNY1D = C<4,3>NETINVN[0]; 
      LNR2A = C<4,3>NETINVN[0]; 
      EDITX = XSFW(SIEMID); 
      LNY1C = C<8,2>EDITX;
      IF C<0,1>MSTRUN[0] EQ 0 THEN MSTRUN[0] = SIEUSER; 
      LNY1E = MSTROIN[0]; 
      LNY1F = MSTRUIN[0]; 
      LNZ1A = XSFW(MSTRRN[0]);
      LNZ1B = XSFW(MSTRMFN[0]); 
      LNZ1C = XSFW(MSTRUN [0]); 
      LNZ4A = XSFW(MSTRUN[0]);
      LNZ4B = XSFW(MSTRFM[0]);
      LNZ4B = SPACES;       # T E M P O R A R Y # 
      LNZ4C = XSFW(MSTRPW[0]);
      IF LNZ1C EQ SPACES THEN LNZ1C = "(UNDEF)";
      IF LNZ4A EQ SPACES THEN LNZ4A = "(UNDEF)";
      IF LNZ4B EQ SPACES THEN LNZ4B = "(N/A)  ";
      IF LNZ4C EQ SPACES THEN LNZ4C = "(UNDEF)";
      IF DISDFLT THEN 
      BEGIN 
      SHOTERM (LOC(LNY0), 1, FALSE);
      SHOTERM (0, 6, FALSE);
      SHOTERM (LOC(LNY3), 6, FALSE);
      SHOTERM (LOC(LNZ0), 7, FALSE);
      SHOTERM (LOC(LNZ4), 7, FALSE);
      SHOTERM (0, 1, TRUE); 
      END 
      OPMSG[0] = LNR; 
      OPMSGZB[4] = 0; 
      SENDMSG;
      OPMSG[0] = LNZ; 
      OPMSGZB[7] = 0; 
      SENDMSG;
 
  END     #DS$DEFAULT#
 
  CONTROL EJECT;
# 
 *  PROC CRACK$CALL 
 *
 *       CALLED FROM SETUP$NAMI 
 *
 *       DEBLOCK THE PARAMETERS IN THE NAMI CALL
 *       STATEMENT AND PRESET SELECTED VARIABLES
 *
 *       VALIDATE ALL KEYWORDS, AND UNSET THE *GO* CONDITION
 *       IF ANY ERRORS ARE DIAGNOSED. 
 *
 *
 *       CALLS SETUPC, UPD8NIN, NEWMAST, UPD8MFN
 *
# 
 
 
  PROC CRACK$CALL;
 
  BEGIN 
 
    ITEM CCERROR  B = FALSE;      #ERROR FLAG                          #
    ITEM CCILLWD  C(10);          #MESSAGE WORD                        #
    ITEM I;                       #SCRATCH                             #
 
    SWITCH KEYWORD,               #CORRESPONDS TO GLOBAL ARRAY KWARRY  #
          KWGO, 
          KWMFN,
          KWOIN,
          KWOPTION, 
          KWPW, 
          KWRN, 
          KWRS, 
          KWSTOP, 
          KWTERM, 
          KWTEST, 
          KWUN; 
 
 
    PROC CC$ERROR;
 
#   WRITE CALL STATEMENT ERROR MESSAGE AND SET ERROR FLAG              #
 
    BEGIN  #PROC CC$ERROR#
    OPMSG[0] = "  NAMI ILLEGAL KEYWORD/VALUE  ";
    OPMSG[3] = CCILLWD; 
    SHOTERM (LOC(OPMSG[0]),4,TRUE); #ERROR MESSAGE TO TERMINAL         #
    OPMSGZB[4] = 0; 
    SENDMSG;                        #ERROR MESSAGE TO DAYFILE          #
    CCERROR = TRUE;                 #SET ERROR FLAG                    #
    END #PROC CC$ERROR# 
 
 
    PROC CC$UPD8; 
 
#   UPDATE INVOCATION NUMBER AND MASTER FILE.  CALL CC$ERROR IF        #
#   NO VALUE SPECIFIED.                                                #
 
    BEGIN #PROC CC$UPD8#
    IF PACKWE[J2] EQ "="
    THEN                               #VALUE SPECIFIED                #
      BEGIN 
      NETINCR[0] = 0; 
      UPD8NIN;
      NEWMAST(SCANK,SCANV); 
      UPD8MFN;
      END 
    ELSE                               #NO  =VALUE  SPECIFIED          #
      BEGIN 
      CCILLWD = SCANK;                 #KEYWORD                        #
      CC$ERROR;                        #ISSUE ERROR MESSAGE            #
      END 
    END #PROC CC$UPD8#
 
 
 
# BEGIN CRACK$CALL PROCEDURE                                           #
 
    PACK80 = SPACES;
    PACK80 = JCAOPMSG;
 
    SETUPC; 
 
 
    FOR J2=1 WHILE PACKZW[J2] NQ 0 DO         #LOOP THRU CALL STMT     #
    BEGIN 
      SCANK = PACKW[J2];
      SCANV = PACKW[J2+1];
      FILL55 (SCANK); 
      FILL55 (SCANV); 
 
      FOR I=1 STEP 1 UNTIL NUMKWDS DO  #LOOP THRU LEGAL KEYWORDS       #
        IF KWORD[I] EQ SCANK      #MATCH FOUND                         #
        THEN
          GOTO KEYWORD[I];        #JUMP TO PROCESS KEYWORD             #
 
      CCILLWD = SCANK;            #ILLEGAL KEYWORD                     #
      CC$ERROR;                   #ISSUE ERROR MESSAGE                 #
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWGO:                             # GO                                 #
      AUTO$GO = TRUE; 
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWTEST:                           # TEST                               #
      TESTING = TRUE; 
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWRN:                             # RN PARAMETER IS SPECIFIED          #
     # WE WANT TO MAKE SURE THAT THE OPERATOR TYPED IN A GOOD RECORD   #
     # NAME FOR THE RN PARAMETER. WHETHER THE TYPED-IN NAME IS GOOD    #
     # CAN NOT BE KNOWN UNTIL WE READ THE NAMSTRT FILE. THIS WILL BE   #
     # DONE IN PRELOAD. FOR NOW, JUST SAVE THE TYPED-IN NAME AND       #
     # REMEMBER THAT RN PARAMETER HAS BEEN ENTERED.                    #
 
      IF PACKWE[J2] EQ "="
      THEN
        BEGIN 
        RNCHANGED = TRUE;         # REMEMBER TO PROCESS RN PARAM LATER #
        RNVALUE = SCANV;          # SAVE THE TYPED-IN RN VALUE         #
        END 
      ELSE
        BEGIN 
        CCILLWD =SCANK; 
        CC$ERROR; 
        END 
 
      GOTO ENDLOOP;               # PROCESS NEXT KEYWORD               #
 
KWMFN:                            # MFN = FILENAM                      #
KWPW:                             # PW  = PASSWOR                      #
KWUN:                             # UN  = USERNUM                      #
      CC$UPD8;                    #UPDATE FILES                        #
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWRS:                             # RS = JOBNAME                       #
      RESTRT = TRUE;
      RSAPPL = SCANV;             #APPLICATION TO RESTART              #
      AUTO$GO = TRUE;             #FORCE THE *GO*                      #
      CC$UPD8;                    #UPDATE FILES                        #
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWOIN:                            # OIN = NNN                          #
                  CALC$OIN(SCANV,FALSE);  #CNVERT OLD INVOCATION NUMBER#
                  CALL$OIN = MSTROIN[0];  #STORE  OLD INVOCATION NUMBER#
                  SCANV    = CALL$OIN;    # SET UP FOR NEWBASE CALL    #
      CC$UPD8;                    #UPDATE FILES                        #
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWOPTION:                         #OPTION = SELECTED OPTION            #
      CCILLWD = " (OPTION) ";     #ILLEGAL ON CALL STATEMENT           #
      CC$ERROR; 
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
KWSTOP:                           # STOP                               #
KWTERM:                           # TERM                               #
      OPTION = OPTTERM;           #TERMINATE NAMI                      #
      GOTO ENDLOOP;               #PROCESS NEXT KEYWORD                #
 
ENDLOOP:                          # END OF LOOP                        #
      IF PACKWE[J2] EQ "="        #INCREMENT PARAMETER INDEX           #
      THEN
        J2 = J2 + 2;
      ELSE
        J2 = J2 + 1;
 
    END #OF LOOP J2#
 
    IF CCERROR                    #ERROR(S) ON CONTROL STATEMENT       #
    THEN
      AUTO$GO = FALSE;            #ALLOW OPERATOR TO CORRECT PARAMETERS#
    IF TESTING                    #TEST MODE                           #
    THEN
      BEGIN                       #SET FLAGS                           #
      CMODE = 1;
      DISDFLT = TRUE; 
      END 
 
  END     #CRACK$CALL#
  CONTROL EJECT;
# 
 *
 *   PROC SETUP$NAMI
 *
 *        CALLED FROM NAMIN 
 *
 *        THIS IS NAMI INITIALIZATION CODE.  VARIOUS TABLES ARE INITIALIZED 
 *        AND MODES (EG., NORMAL/DEBUG) ARE CHECKED.  CERTAIN VALUES ARE
 *        ALSO PRESET.
 *
 *        CALLS INITCPA, CLR$OP$MSG, SENDMSG, PRELOAD 
 *
# 
 
  PROC SETUP$NAMI;
 
  BEGIN 
 
      IOFLG = 2;
      STARTIO;
      RESTRT = FALSE; 
      APFOUND = FALSE;
 
      MSTROIN[0] = "000"; 
      CALL$OIN = SPACES;
      CMODE = 3;
      CRACK$CALL; 
 
 
      INITCPA;
 
      IF NOT TESTING
      THEN
        BEGIN 
        CHEKORG;                        # ABORT IF NOT SYS ORG OR CSOJ #
        SETNUN;                         # SET NAMI USER NUMBER         #
        END 
 
      FOR N = 0 STEP 1 UNTIL 200 DO 
      BEGIN 
        RTFN[N]     = SPACES; 
        RTFNCD[N]   = 0;
        JBL1[N]     = SPACES; 
        JBL2[N]     = SPACES; 
        JBL3[N]     = SPACES; 
      END 
 
      JOBNAME = SPACES; 
      JOBINDX = 0;
 
 
      CTLRCDS = 0;
      RUNRCDS = 0;
 
      PRELOAD;
 
      IF RNCHANGED
      THEN                   # A NEW RN PARAMETER HAS BEEN ENTERED #
        BEGIN  # PROCESSING RN PARAMETER #
        FOUND = FALSE;
        FOR N=0 STEP 1 WHILE (N LQ LASTENTRY) AND (NOT FOUND) DO
          BEGIN 
          IF (DIR$NAME[N] EQ RNVALUE) AND (DIR$TYPE[N] EQ PTYPE)
          THEN                    # THE TYPED-IN RN VALUE IS GOOD  #
            BEGIN 
            FOUND = TRUE; 
            NETINCR[0] = 0; 
            UPD8NIN;
            RNKEYWORD = "RN"; 
            NEWMAST (RNKEYWORD,RNVALUE);
            UPD8MFN;
            END #IF#
          END #FOR# 
 
        IF N GR LASTENTRY 
        THEN       # NO PARAM RECORD MATCHED THE TYPED-IN RN VALUE #
          BEGIN 
          AUTO$GO = FALSE;        # BAD RN VALUE. DO NOT GO AHEAD  #
          OPMSG[0] = " PARAMETER RECORD NOT FOUND :"; 
          OPMSG1[3] = RNVALUE;
          SHOTERM (LOC(OPMSG[0]),4,TRUE); # ERROR MESSAGE TO TERMINAL # 
          OPMSGZB[4] = 0; 
          SENDMSG;                        # MESSAGE TO DAYFILE        # 
          END 
        RNCHANGED =FALSE;                   # RESET RNCHANGED FLAG #
        END # PROCESSING RN PARAMETER # 
 
      OPTION = OPTLOAD; 
      TBLPTR = DISPJBS; 
      NEED$OPRES = FALSE; 
 
  END #SETUP$NAMI#
 
  CONTROL EJECT;
# 
 *
 *   PROC DFL$RCDS
 *
 *        CALLED FROM NEWBASE, SELJOB$LOD 
 *
 *        SEND A LIST THE OF JOB AND PARAMETER RECORDS TO THE JOB 
 *        DAYFILE.  THIS IS DONE TO ASSIST THE OPERATOR IN SELECTING
 *        A JOB/PARAMETER RECORD IN LIEU OF THE K/L-DISPLAY.
 *
 *        CALLS CLR$OP$MSG, SENDMSG 
 *
# 
 
  PROC DFL$RCDS;
 
  BEGIN 
 
    ITEM TYPNDX     I;
 
    FOR TYPNDX = JTYPE WHILE TYPNDX NQ ZTYPE DO 
    BEGIN 
      OPMSG[0] = " JOB   RECORD NAMES--"; 
      IF TYPNDX EQ PTYPE THEN C<0,6>OPMSG[0] = " PARAM";
      SHOTERM (LOC(OPMSG[0]), 4, FALSE);
      OPMSGZB[4] = 0; 
      SENDMSG;
      N1 = 0; 
 
      FOR N2 = 0 STEP 1 WHILE DIR$NAME[N2] NQ SPACES DO 
      BEGIN 
        IF DIR$TYPE[N2] EQ TYPNDX THEN
        BEGIN 
          IF N1 EQ 0 THEN CLR$OPMSG;
          C<1,7>OPMSG1[N1] = C<0,7>DIR$NAME[N2];
          N1 = N1 + 1;
        END 
        IF N1 NQ 0                     #SOMETHING IN BUFFER            #
          AND DIR$NAME[N2+1] EQ SPACES   #AND END OF DIRECTORY         #
        THEN
          N1 = 4; 
        IF N1 EQ 4 THEN 
        BEGIN 
          SHOTERM (LOC(OPMSG[0]), 4, TRUE); 
          OPMSGZB[4] = 0; 
          SENDMSG;
          N1 = 0; 
        END 
      END 
      IF TYPNDX EQ PTYPE THEN TYPNDX = ZTYPE; 
      IF TYPNDX EQ JTYPE THEN TYPNDX = PTYPE; 
    END 
  END #DFL$RCDS#
  CONTROL EJECT;
 
# 
 *   PROC CHECK$OPTION
# 
 
  PROC CHECK$OPTION (OPVALUE);
 
  BEGIN 
 
    ITEM OPVALUE    C(10);
      IF C<0,4>OPVALUE EQ "SHOW" THEN OPTION = OPTDISP;  #SHOW OPTS#
      IF C<0,4>OPVALUE EQ "SELE" THEN OPTION = OPTLOAD;  #SELECT JOB# 
      IF C<0,4>OPVALUE EQ "MODI" THEN OPTION = OPTMOD;   #MODIFY JOB# 
      IF C<0,4>OPVALUE EQ "SAVE" THEN OPTION = OPTSAVE;  #SAVE JOB# 
      IF C<0,4>OPVALUE EQ "SUBM" THEN OPTION = OPTSBMT;  #SUBMIT JOB# 
      IF C<0,4>OPVALUE EQ "TERM" THEN OPTION = OPTTERM;  #TERMINATE#
      IF C<0,4>OPVALUE EQ "STOP" THEN OPTION = OPTTERM;  #TERMINATE#
      IF C<0,4>OPVALUE EQ "ROUT" THEN OPTION = OPTROUT;  #ROUTE IMED# 
      IF C<0,6>OPVALUE EQ "NODISP" THEN DSPLYMODE = FALSE;
      IF C<0,6>OPVALUE EQ "DISPLA" THEN DSPLYMODE = TRUE; 
      TBLPTR = DISPOPT; 
      IF OPTION EQ OPTLOAD THEN TBLPTR = DISPJBS; 
      IF OPTION EQ OPTMOD  THEN TBLPTR = DISPCCB; 
      IF OPTION EQ OPTSAVE THEN TBLPTR = DISPCCB; 
      IF OPTION EQ OPTSBMT THEN TBLPTR = DISPZRO; 
      IF OPTION EQ OPTSBMT THEN RUNJOB = TRUE;
      IF OPTION EQ OPTSBMT THEN RT$IMMED = TRUE;
 
  END  #CHECK$OPTION# 
 
  CONTROL EJECT;
 
# 
 *
 *   PROC GET$NXT$OP
 *
 *        CALLED FROM NAMIN 
 *
 *        IF WE ARE IN AUTOMATIC MODE (OPERATOR HAS SELECTED A PARAMETER
 *        RECORD WHICH INDICATES WHICH JOBS TO LOAD AND ROUTE TO THE INPUT
 *        QUEUE), THE OPTION IS FORCED TO BE SELECT-SAVE-ROUTE. 
 *
 *        OTHERWISE, WE DISPLAY TO THE OPERATOR (K/L-DISPLAY OR TERMINAL) 
 *        THE LIST OF OPTIONS AND READ (VIA CFO OR TERMINAL INPUT)
 *        THE OPERATOR CHOICE OF OPERATION.  THE VALID OPTIONS ARE- 
 *
 *              DISPLAY OPTIONS 
 *              SELECT JOB/PARAMETER RECORD 
 *              MODIFY JOB RECORD 
 *              SAVE JOB RECORD 
 *              ROUTE JOB RECORD TO INPUT QUEUE 
 *              TERMINATE THE RUN 
 *
 *        ALL INPUT MUST BE OF THE FORM-
 *
 *             CFO.MESSAGE
 *
 *        WE COMPARE THE FIRST THREE CHARACTERS OF MESSAGE WITH THE LIST
 *        OF OPTIONS (EG, SEL, MOD, TER). 
 *
 *        CALLS DISPLAY$L, READ$CFO, CSCAN
 *
# 
 
  PROC GET$NXT$OP;
 
  BEGIN 
 
     NEED$OPRES = FALSE;
      IF NXT2LOD NQ 0 THEN
      BEGIN 
        OPTION = OPTLOAD; 
        TBLPTR = DISPJBS; 
        IF JBL1[NXT2LOD-1] EQ SPACES THEN NXT2LOD = 0;
      END 
 
      IF (NXT2LOD EQ 0) AND (AUTO$GO) THEN OPTION = OPTTERM;
 
      IF (NXT2LOD EQ 0) AND (NOT AUTO$GO) THEN
      BEGIN 
        RUNJOB = FALSE; 
        CTLJOB = FALSE; 
          TBLPTR = DISPOPT; 
          DISPLAY$L;
          FOR CSTAT = 2 WHILE CSTAT EQ 2 DO 
          BEGIN 
            CSTAT = 2;
            READ$CFO;             # -- CONSOLE INPUT -- # 
            OPTION = OPTROUT+1; 
            EDITX = C<0,6>CMESS[0]; 
            CHECK$OPTION (EDITX); 
            IF OPTION GR OPTROUT THEN CSTAT = 2;
          END 
      END 
 
  END     #GET$NXT$OP#
 
 
  CONTROL EJECT;
 
# 
 *
 *   PROC ROUT$FILES
 *
 *        CALLED FROM NAMIN 
 *
 *        THE ROUTE-FILE QUEUE (ARRAY IN COMMON AREA ROUTABL) IS
 *        EXAMINED AND FOR EACH FILE NAME FOUND, THAT FILE IS 
 *        ROUTED TO THE INPUT QUEUE.  THIS ROUTINE IS CALLED AS PART
 *        OF THE JOB TERMINATION PROCESSING.  IN THAT WAY, ALL
 *        NETWORK JOBS ARE STARTED (ROUGHLY) SIMULTANEOUSLY.
 *
 *        CALLS XSFW, ROUTEM, SHOTERM 
 *
# 
 
  PROC ROUT$FILES;
 
  BEGIN 
 
    FOR N = 0 STEP 1 WHILE RTFN[N] NQ SPACES DO 
    BEGIN 
      ROUTYPE = 0;
      IF TESTING THEN ROUTYPE = 63; 
      ROUTNAM = RTFN[N];
      RSTM3 = XSFW(ROUTNAM);
      ROUTCOD = ROUTIQ; 
        IF C<0,2>ROUTNAM EQ "NI" THEN 
        BEGIN 
          ROUTCOD = ROUTCOD + ROUTNIP ; 
          START$SUBS = TRUE;
          INDXC = N;
        END 
        ELSE
        BEGIN 
          IF RTFNCD[N] NQ 0 THEN
          BEGIN 
            ROUTCOD = ROUTCOD + ROUTSS; 
          END 
          RTEOT = RTFNOT[N];
          RTESC = RTFNSC[N];
          IF RTESC EQ 1 
             THEN RTESC = "SY"; 
             ELSE IF RTESC EQ 2 
                     THEN RTESC = "BC"; 
                     ELSE IF RTESC EQ 3 
                             THEN RTESC = "NS"; 
          ROUTEM; 
          ROUTCOD = 0;
        END 
      EDITX = XCOD(ROUTCOD);
      RSTM2 = C<6,4>EDITX;
      SHOTERM (LOC(RSTM0), 4, TRUE);
      IF ROUTCOD EQ 0 THEN RTFN[N] = SPACES;
      IF ROUTCOD EQ 0 THEN RTFNCD[N] = 0; 
    END 
    RT$IMMED = FALSE; 
 
  END  #ROUT$FILES# 
  CONTROL EJECT;
# 
 *
 *   PROC FILL55     (FILET)
 *
 *        CALLED FROM PRELOAD, FIND$JOB, SELJOB$LOD, LOAD$JOB 
 *
 *        THE 10 CHARACTER WORD (FILET) IS EXAMINED CHARACTER BY
 *        CHARACTER AND EACH NON-ALPHANUMERIC CHARACTER IS REPLACED 
 *        BY A BLANK. 
 *
# 
 
  PROC FILL55 (FILET);
 
  BEGIN 
 
    ITEM FILET      C(10);
    ITEM N2         I;
 
    FOR N2 = 0 STEP 1 UNTIL 9 DO
        IF (C<N2,1>FILET LS "A") OR 
           (C<N2,1>FILET GR "9") THEN 
            C<N2,1>FILET = " "; 
 
    END     #FILL55#
 
  CONTROL EJECT;
# 
 *     PROC PRELOAD 
 *
 *        PRELAOD READS THE NETWORK MASTER FILE (LFN=INFILE)
 *        AND BUILDS THE DIRECTORY TABLE. EACH ENTRY IN THE 
 *        TABLE CONSISTS OF THREE FIELDS: 
 *           - DIR$NAME : NAME OF THE CORRESPONDING RECORD. 
 *           - DIR$TYPE : TYPE OF THE RECORD -- EITHER
 *                        PARAMETER RECORD OR JOB RECORD. 
 *           - PRU$ADDR : THE RELATIVE SECTOR ADDRESS OF THE
 *                        RECORD. 
# 
     PROC PRELOAD;
     BEGIN # PRELOAD #
 
       NETINCR[0] = 0;
       UPD8NIN; 
       GNETCCL; 
       FET$RR = 1;           # PRESET THE CRI AND RR FIELD OF THE    #
       FET$CRI = 1;          #     FET TO THE FIRST PRU OF THE FILE. #
       RUNRCDS = 0;          # PRESET JOB-RECORD COUNTER.            #
       CTLRCDS = 0;          # PRESET PARAMETER-RECORD COUNTER.      #
 
       IF C<0,1>PFERMSG NQ 0 THEN       # COULD NOT GET NAMSTRT FILE #
         BEGIN
         SHOTERM (LOC(PFERMSG), 4, FALSE);
         PFERMSG = " MASTER FILE NOT PRESENT";
         SHOTERM (LOC(PFERMSG), 4, TRUE); 
         DIR$NAME[0] = SPACES;                # TABLE END            #
         DIR$TYPE[0] = ZTYPE;                 #           INDICATORS #
         GOTO ENDLOOP;
         END
 
       FOR N=0 STEP 1 WHILE (FET$STAT NQ STAT$EOF)
                             AND (FET$STAT NQ STAT$EOI) DO
         BEGIN
         IF N GR 200 THEN 
           ABORTRUN(1);                 # DIRECTORY TABLE OVERFLOWED #
         PRU$ADDR[N]= FET$CRI[0];  #RELATIVE SECTOR ADDRESS OF RECORD#
         FET$IN = FET$FIRST;            # RESET IN AND OUT POINTERS  #
         FET$OUT = FET$FIRST;           #                 IN THE FET.#
         READSKP (INFIL,0);            # READ AND SKIP TO NEXT RECORD#
         RECALL (INFIL);
 
         IF (FET$STAT NQ STAT$EOF) AND (FET$STAT NQ STAT$EOI) 
         THEN 
           BEGIN
           READH (INFIL,ONELINE,9,STATS); #READ FIRST LINE OF RECORD #
           JOBNAME = LIN$10[0];  # EXTRACT RECORD NAME FROM 1ST LINE #
           FILL55 (JOBNAME);        # SPACE FILL RECORD NAME         #
           DIR$NAME[N] = JOBNAME;   # STORE RECORD NAME IN DIRECTORY #
 
           READH (INFIL,ONELINE,9,STATS); #READ SECOND LINE OF RECORD#
           RECORDTYPE = C<6,3>LIN$100;      # FIGURE OUT RECORD TYPE #
 
           IF RECORDTYPE EQ "PAR       "
           THEN 
             BEGIN                    # PARAMETER RECORD ENCOUNTERED #
             DIR$TYPE[N] = PTYPE;                # STORE RECORD TYPE #
             CTLRCDS = CTLRCDS+1;  #INCRECMENT PARAMETER RECORD COUNT#
             END
           ELSE IF RECORDTYPE EQ "JOB       " 
           THEN 
             BEGIN                          # JOB RECORD ENCOUNTERED #
             DIR$TYPE[N] = JTYPE;                # STORE RECORD TYPE #
             RUNRCDS = RUNRCDS + 1;    # INCRECMENT JOB RECORD COUNT #
             END
           ELSE 
             BEGIN                             # UNKNOWN RECORD TYPE #
             OPMSG[0]="  ERROR IN NAMSTRT FILE. UNKNOWN RECORD TYPE.";
             OPMSGZB[5] = 0;
             SENDMSG;             # SEND A DAYFILE MESSAGE,          #
             ABTRUN;              # AND ABORT THE PROGRAM.           #
             END
           END
 
         ELSE  # EOF OR EOI ENCOUNTERED # 
           BEGIN
           DIR$NAME[N] = SPACES;      # AS AN END OF DATA INDICATOR  #
           DIR$TYPE[N] = ZTYPE; 
           LASTENTRY = N - 1;         # LAST ENTRY IN THE TABLE      #
           END
 
         END # FOR #
 
ENDLOOP:  
         PRLDNIN; 
 
     END # PRELOAD #
 
  CONTROL EJECT;
# 
 *
 *   PROC INTRACT 
 *
 *        CALLED FROM RLOD$DISP 
 *
 *        THE NEXT LINE OF DATA IS ENTERED INTO THE K/L-DISPLAY 
 *        BUFFER. 
 *
# 
 
  PROC INTRACT (NDX1, NXT); 
 
  BEGIN 
 
    ITEM NDX1       I;
    ITEM CNT        I;
    ITEM NXT        I;
    ITEM MORE$2$DO  B;
 
    NXT = NDX1; 
    MORE$2$DO = TRUE; 
 
    FOR CNT = 1 STEP 1 WHILE MORE$2$DO DO 
    BEGIN 
      CHX[NDX1+CNT] = XSFW(LINX[CNT-1]);
      IF (CNT+1) GQ CWC[NDX1] THEN MORE$2$DO = FALSE; 
    END 
 
    NXT = NDX1 + CWC[NDX1]; 
 
  END     #INTRACT# 
 
 
  CONTROL EJECT;
 
# 
 *
 *   PROC EXTRACT 
 *
 *        CALLED FROM DISPLAY$L 
 *
 *        THIS IS THE OPPOSITE OF INTRACT.  HERE THE NEXT LINE OF THE 
 *        CURRENT K/L-DISPLAY BUFFER IS EXTRACTED AND MADE AVAILABLE
 *        FOR PROCESSING. 
 *
# 
 
  PROC EXTRACT (NDX1, CNT, NXT);
 
  BEGIN 
 
    ITEM NDX1       I;
    ITEM CNT        I;
    ITEM NXT        I;
    ITEM MORE$2$DO  B;
 
    NXT = 0;
    MORE$2$DO = TRUE; 
    FOR CNT = 0 STEP 1 UNTIL 9 DO 
        LINX[CNT] = SPACES; 
 
    IF CWC[NDX1] GR 1 THEN
    BEGIN 
      FOR CNT = 1 STEP 1 WHILE MORE$2$DO DO 
      BEGIN 
        LINX[CNT-1] = CHX[NDX1+CNT];
        IF (CNT+1) EQ CWC[NDX1] THEN MORE$2$DO = FALSE; 
      END 
    END 
 
    NXT = NDX1 + CWC[NDX1]; 
    CNT = NXT - NDX1; 
 
  END     #EXTRACT# 
  CONTROL EJECT;
 
# 
 *
 *   PROC FIND$JOB
 *
 *        CALLED FROM LOAD$JOB
 *
 *        THE DIRECTORY TABLE IS SEARCHED FOR THE DESIRED RECORD
 *        NAME. IF THE NAME IS FOUND, RETRIEVE THE RELATIVE SECTOR
 *        ADDRESS FROM THE DIRECTORY TABLE AND STORE IT IN THE RR 
 *        FIELD OF THE FET TO UTILIZE A RANDOM READ. THE FIRST 3
 *        LINES OF THE RECORD ARE THEN READ OFF TO MAKE THE SITUA-
 *        TION COMPATIBLE WITH THE EXITSTING CODE IN THE CALLER --
 *        LOAD$JOB. 
 *
 *        CALLS UPD8NIN, GNETCCL, GETLINE, CSCAN, FILL55, 
 *
# 
 
  PROC FIND$JOB;
 
  BEGIN 
 
    IF INV$INCR AND NOT RESTRT
    THEN                     # NIP APPEARS IN JOB STREAM               #
    BEGIN 
      NETINCR[0] = 1; 
      UPD8NIN;
      GNETCCL;
      INV$INCR = FALSE; 
      LNR2A = C<4,3>NETINVN[0]; 
      OPMSG[0] = LNR; 
      OPMSGZB[4] = 0; 
      SENDMSG;
      SHOTERM (LOC(LNR0), 4, TRUE); 
    END 
 
    IF CALL$OIN EQ SPACES 
    THEN
      CALC$OIN(NETINVN[0],TRUE);       #STORE OIN = NIN-1              #
 
    IOFWA = LOC(LINX[0]); 
 
    FOR I=0 STEP 1 WHILE I LQ LASTENTRY AND (DIR$NAME[I] NQ JOBNAME) DO 
      BEGIN 
      END 
 
    IF DIR$NAME[I] EQ JOBNAME 
    THEN
      BEGIN 
      FET$RR[0] = PRU$ADDR[I]; #STORE THE SECTOR ADDRESS INTO THE FET # 
      FET$IN[0] = FET$FIRST[0];       # RESET IN AND                  # 
      FET$OUT[0] =FET$FIRST[0];       #              OUT PONTERS.     # 
      GETLINE;
      GETLINE;
      GETLINE;
      END 
    ELSE
      BEGIN 
      OPMSG[0] = " COULD NOT FIND JOB NAME:"; 
      OPMSG1[3] = JOBNAME;
      OPMSGZB[4] = 0; 
      SENDMSG;
      ABTRUN; 
      END 
 
  END #FIND$JOB#
 
  CONTROL EJECT;
 
# 
 *
 *   PROC CLRTABLE
 *
 *        CALLED FROM LOADJOB 
 *
 *        CLEAR THE L-DISPLAY CARD/LINE BUFFER. 
 *
# 
 
  PROC CLRTABLE;
 
  BEGIN 
 
    N = CWC[0]; 
 
    FOR N1 = 0 WHILE N LS TLEN[TBLPTR] DO 
    BEGIN 
      N2 = CWC[N];
      IF N2 EQ 0 THEN N2 = N; 
      IF N2 EQ 7 THEN 
      BEGIN 
        CHLOW[N] = "--";
        FOR N1 = 1 STEP 1 UNTIL 6 DO
          CHX[N+N1] = SPACES; 
      END 
      N = N + N2; 
    END 
 
  END #CLRTABLE#
 
  CONTROL EJECT;
 
 
# 
 *
 *   PROC NEWBASE 
 *
 *        CALLED FROM SELJOB$LOD
 *
 *        WHEREIN WE SCAN THE OPERATOR INPUT (CFO) MESSAGE AND SEND 
 *        THE NEW NETWORK CCL FILE NAMING INFORMATION (PFN, UN, ETC)
 *        TO NEWMAST WHICH GETS THE NEW MASTER FILE.
 *
 *        AFTER THE NEW FILE IS OPENED, NAMI IS IN EFFECT RESTARTED 
 *        (ACUTALLY RESET) TO BEGIN AGAIN WITH THE NEW MASTER FILE. 
 *
 *        CALLS NEWMAST, UPD8MFN, PREL$JOBS, DFL$RCDS, DS$DEFAULT, DISPLAY$L
 *
# 
 
  PROC NEWBASE; 
 
  BEGIN 
 
 
    SWITCH KEYWORD,                    #CORRESPONDS TO ARRAY KWARRY    #
          KWGO, 
          KWMFN,
          KWOIN,
          KWOPTION, 
          KWPW, 
          KWRN, 
          KWRS, 
          KWSTOP, 
          KWTERM, 
          KWTEST, 
          KWUN; 
 
    ITEM I;                            #SCRATCH                        #
    ITEM IERROR B;                     #ERROR FLAG                     #
 
    IERROR = FALSE; 
 
    PACK80 = CMSG80[0]; 
    SETUPC;                            #UNPACK CFO COMMAND             #
 
    UPCFLAG = TRUE; 
    FOR K=0 WHILE UPCFLAG DO           #LOOP THROUGH CFO COMMAND       #
    BEGIN 
      SCANK = PACKW[K]; 
      SCANV = PACKW[K+1]; 
      FILL55(SCANV);
      FILL55(SCANK);
      FOR I=1 STEP 1 UNTIL NUMKWDS DO  #FIND KEYWORD MATCH             #
        IF KWORD[I] EQ SCANK
        THEN
          GOTO KEYWORD[I];
 
      IF SCANK EQ SPACES               #END OF CFO COMMAND FOUND       #
      THEN
        BEGIN 
        UPCFLAG = FALSE;
        TEST  K;
        END 
 
                                       #FALL THRU TO HERE ON NO MATCH  #
     KWTEST:                           #TEST NOT ALLOWED AS CFO COMMAND#
        OPMSG[0] = " ILLEGAL KEYWORD  =  "; 
        OPMSG[2] = SCANK; 
        SHOTERM (LOC(OPMSG[0]),3,TRUE); 
        OPMSGZB[3] = 0; 
        SENDMSG;
        IERROR = TRUE;
        GOTO ENDLOOP; 
 
KWGO:                                  #GO                             #
        AUTO$GO = TRUE; 
        GOTO ENDLOOP; 
 
KWMFN:                                 #MFN =                          #
KWPW:                                  #PW  =                          #
KWUN:                                  #UN  =                          #
        NEWMAST (SCANK,SCANV);
        GOTO ENDLOOP; 
 
KWRN:                                  #RN  =                          #
      # BEFORE UPDATING THE RN VALUE IN THE MEMORY FILE, WE WANT TO BE #
      # SURE THAT THE TYPED-IN NAME FOR RN MATCHES ONE OF THE PARAMETER#
      # RECORDS IN THE LATEST MFN FILE. SINCE MFN AND RN MAY BE CHANGED#
      # BY THE SAME COMMAND, WE WILL DEFER THE PROCESSING OF THE RN    #
      # PARAMETER UNTIL AFTER THE WHOLE COMMAND IS PROCESS, AND THE NEW#
      # MFN, IF ONE HAS BEEN ENTERED, IS READ.                         #
 
        RNCHANGED =TRUE;          # REMEMBER TO PROCESS RN PARAM LATER #
        RNVALUE = SCANV;          # SAVE THE TYPED-IN RN VALUE         #
        GOTO ENDLOOP;             # PROCESS NEXT KEYWORD               #
 
KWRS:                                  #RS =                           #
        RESTRT = TRUE;
        RSAPPL = SCANV; 
        AUTO$GO = TRUE; 
        NEWMAST (SCANK,SCANV);
        GOTO ENDLOOP; 
 
KWOIN:                                 #OIN =                          #
        CALC$OIN (SCANV,FALSE);        #CONVERT OLD INVOCATION NUMBER  #
        CALL$OIN = MSTROIN [0];        #STORE   OLD INVOCATION NUMBER  #
        SCANV    = CALL$OIN;           # SET UP FOR NEWBASE CALL       #
        GOTO ENDLOOP; 
 
KWOPTION: 
        CHECK$OPTION(SCANV);
        CSTAT = 0;
        GOTO ENDLOOP; 
 
KWSTOP:                                #STOP                           #
KWTERM:                                #TERM                           #
        OPTION = OPTTERM; 
        GOTO ENDLOOP; 
 
ENDLOOP:  
        IF PACKWE[K] EQ "="            #INCREMENT PARAMETER INDEX      #
        THEN
          K = K + 2;
        ELSE
          K = K + 1;
 
    END 
 
    IF IERROR 
    THEN
      AUTO$GO = FALSE;                 #NO GO YET IF ERRORS FOUND      #
 
    IF OPTION EQ OPTLOAD THEN 
                         BEGIN
                           UPD8MFN; 
                           PRELOAD; 
 
                           IF NOT RNCHANGED THEN
                           BEGIN
                             # NOTE: IF RN IS ENTERED, WE WILL CALL    #
                             # DS$DEFAULT AND DFL$RCDS LATER AFTER WE  #
                             # HAVE UPDATED RN.                        #
                             DS$DEFAULT;
                             DFL$RCDS;
                           END
                         END
 
    IF RNCHANGED THEN 
    BEGIN     # PROCESSING RN PARAMETER # 
      FOUND = FALSE;
      FOR N=0 STEP 1 WHILE (N LQ LASTENTRY) AND (NOT FOUND) DO
      BEGIN 
        IF (DIR$NAME[N] EQ RNVALUE) AND (DIR$TYPE[N] EQ PTYPE) THEN 
        BEGIN                     # THE TYPED-IN RN VALUE IS GOOD  #
          FOUND = TRUE; 
          RNKEYWORD = "RN"; 
          NEWMAST (RNKEYWORD,RNVALUE);
        END #IF#
      END #FOR# 
 
      IF N GR LASTENTRY THEN
      BEGIN         # NO PARAM RECORD MATCHED THE TYPED-IN RN VALUE # 
        AUTO$GO = FALSE;           # BAD RN VALUE. DO NOT GO AHEAD  # 
        OPMSG[0] = " PARAMETER RECORD NOT FOUND :"; 
        OPMSG1[4] = RNVALUE;
        SHOTERM (LOC(OPMSG[0]),5,TRUE); # ERROR MESSAGE TO TERMINAL # 
        OPMSGZB[5] = 0; 
        SENDMSG;
      END 
      RNCHANGED =FALSE;                      # RESET RNCHANGED FLAG # 
      DS$DEFAULT;        # DISPLAY CURRENT DEFAULT PARAMETER VALUES # 
      DFL$RCDS;                # DISPLAY PARAMETER/JOB RECORD NAMES # 
    END # PROCESSING RN PARAMETER#
 
  END #NEWBASE# 
  CONTROL EJECT;
 
# 
 *
 *   PROC DSPLAY$LIN
 *
 *        CALLED FROM DISPLAY$L 
 *
 *        DSPLAY$LIN IS RESPONSIBLE FOR DETERMINING WHETHER OR NOT THE
 *        CURRENT LINE OF DATA IN THE K/L-DISPLAY BUFFER IS TO BE SENT
 *        TO THE TERMINAL.  THIS IS PRIMARILY USED FOR TESTING. 
 *
 *        CALLS SHOTERM 
 *
# 
 
  PROC DSPLAY$LIN;
 
  BEGIN 
 
  ITEM NO$DISP B; 
 
    DLNUM1 = XCDD(INDX1*10000000);
    IF DLNUM2 EQ "   " THEN DLNUM2 = "  0"; 
    K = (WORDCNT + 1) * 10; 
    C<0,K>DATALN = C<0,K>LINX1A[0]; 
    IF (LINX[1] EQ SPACES) AND (LINX[2] EQ SPACES)
       THEN SKPLNS = SKPLNS +1; 
       ELSE SKPLNS = 0; 
 
    NO$DISP = FALSE;
    IF (NOT DSPLYMODE) THEN NO$DISP = TRUE; 
    IF (NXT2LOD NQ 0) AND (TBLPTR EQ DISPJBS) THEN NO$DISP = TRUE;
    IF (NXT2LOD NQ 0) AND (TBLPTR EQ DISPOPT) THEN NO$DISP = TRUE;
    IF SKPLNS GQ 2 THEN NO$DISP = TRUE; 
    IF TBLPTR EQ DISPZRO THEN NO$DISP = TRUE; 
    IF (OPTION EQ OPTSAVE) THEN NO$DISP = TRUE; 
    IF ((OPTION EQ OPTLOAD) AND (TBLPTR EQ DISPCCB))
         THEN NO$DISP = TRUE; 
 
    IF (NOT NO$DISP) THEN 
    BEGIN 
      IF (NOT DISEND) THEN SHOTERM (LOC(DATALN), WORDCNT+1, FALSE); 
                      ELSE SHOTERM (LOC(DATALN), WORDCNT+1, TRUE);
    END 
 
  END #DSPLAY$LIN#
 
  CONTROL EJECT;
 
# 
 *   PROC DISPLAY$L 
# 
 
  PROC DISPLAY$L; 
 
  BEGIN 
 
      P<MSGTBL> = TADR[TBLPTR]; 
      DISEND = FALSE; 
      INDX3 = 0;
 
      FOR INDX1 = 0 STEP 1 WHILE NOT DISEND DO
      BEGIN   #DISPLAY LOOP#
 
      INDX2 = INDX3;
      EXTRACT (INDX2, WORDCNT, INDX3);
 
      FOR N = 0 STEP 1 UNTIL 8 DO 
        LINX[9-N] = LINX[8-N];
      LINX[0] = CHX[INDX2]; 
 
          FOR K = 0 STEP 1 UNTIL 5 DO 
            C<K,1>LINX[0] = " ";
 
          IF WORDCNT EQ 0 THEN
          BEGIN 
            LINX[0] = SPACES; 
            LINX[1] = SPACES; 
            LINX[2] = " -DISEND- "; 
            DISEND = TRUE;
            WORDCNT = 2;
          END 
 
 
          DSPLAY$LIN; 
 
 
          END      #DISPLAY LOOP# 
 
  END     #DISPLAY$L# 
  CONTROL EJECT;
 
# 
 *
 *   PROC SELJOB$LOD
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        WHEREIN WE SELECT WHICH PARAMETER OR JOB RECORD WE NEED FROM
 *        THE NETWORK CCL FILE (LFN=INFIL).  DURING THIS PROCESS, WE
 *        ALSO CHECK FOR THE OPERATOR ENTERING NEW CCL FILE PARAMETERS
 *        (EG., NAME, USER NUMBER, ETC.) AND SET UP TO USE A NEW CCL
 *        FILE IF NECESSARY.
 *
 *        TWO TYPES OF RECORDS MAY BE SELECTED - PARAMETER RECORDS AND
 *        JOB RECORDS.  PARAMETER RECORDS CONTAIN SUBSTITUTABLE PARAMETERS
 *        FOR THE JOB CCL STATEMENTS, AS WELL AS A LIST OF WHICH JOB
 *        RECORDS ARE TO BE LOADED.  JOB RECORDS ARE JUST THAT- CCL 
 *        STATEMENTS FOR AN INDIVIDUAL JOB WHICH WILL BE ROUTED TO THE
 *        INPUT QUEUE.
 *
 *        THIS ROUTINE IS ALSO ENTERED DURING AUTOMATIC MODE.  IF A PARAMETER 
 *        RECORD WITH A LIST OF JOBS WAS SELECTED, WE ENTER THIS AUTO 
 *        MODE AND RUN THROUGH THE VARIOUS ROUTINES REQUIRED TO PREPARE THE 
 *        JOB TO BE SENT TO THE INPUT QUEUE FOR EACH JOB IN THE LIST.  THIS 
 *        DOES NOT REQUIRE OPERATOR INTERVENTION, HENCE, THE AUTO MODE. 
 *
 *        CALLS DFL$RCDS, DISPLAY$L, READ$CFO, KEYLINE, NEWBASE, CSCAN
 *              CLR$OPMSG, SENDMSG, SHOTERM, UPD8MFN, FILL55
 *
# 
 
  PROC SELJOB$LOD;
 
  BEGIN 
        SJL$SEARCH: 
        IF JOBINDX EQ 0 THEN
        BEGIN 
          JOBNAME = SPACES; 
          ROUTNAM = "ROUTFIL";
          CTLJOB = FALSE; 
          RUNJOB = FALSE; 
          IF NXT2LOD EQ 0 THEN
          BEGIN 
            TBLPTR = DISPJBS; 
            DFL$RCDS; 
            FOR CSTAT = 2 WHILE CSTAT NQ 0 DO 
            BEGIN 
              CSTAT = 2;
              IF AUTO$GO THEN DS$DEFAULT; 
              IF AUTO$GO THEN CMSG80[0] = "GO.       "; 
                         ELSE READ$CFO; 
              LIN80[0] = CMSG80[0]; 
              IF KEYLINE THEN 
              BEGIN 
                CSTAT = 2;
                NEWBASE;
              END 
              ELSE CSTAT = 0; 
              IF C<0,4>CMSG80[0] EQ "TERM" THEN OPTION = OPTTERM; 
              IF C<0,4>CMSG80[0] EQ "STOP" THEN OPTION = OPTTERM; 
            END 
          END 
          ELSE
          BEGIN 
            JOBNAME   = JBL1[NXT2LOD-1];    #JOB RECORD NAME# 
            ROUTNAM   = JBL2[NXT2LOD-1];    #ROUTE AND PRODUCT NAME#
            SUBSYSNAM = JBL3[NXT2LOD-1];    #SUBSYSTEM NAME#
              ROUTYPE = 0;
            IF SUBSYSNAM NQ SPACES THEN ROUTYPE = 1;
            IF SUBSYSNAM NQ SPACES THEN ROUTNAM = SUBSYSNAM;
            JOBOT = JBL3OT[NXT2LOD-1];                        # JOB OT #
            JOBSC = JBL3SC[NXT2LOD-1];                        # JOB SC #
            JOBINDX = NXT2LOD + CTLRCDS;
            NXT2LOD = NXT2LOD +1; 
            RUNJOB = TRUE;
          END 
 
  CONTROL EJECT;
 
          IF (JOBINDX EQ 0) AND (OPTION EQ OPTLOAD) THEN
          BEGIN 
            PACK80 = CMSG80[0]; 
            SETUPC; 
            JOBNAME = PACKW[0]; 
            FILL55 (JOBNAME); 
            IF JOBNAME EQ "GO"          #GO                            #
                AND PACKZW[1] EQ 0      #   ALONE IN CFO COMMAND       #
            THEN
              AUTO$GO = TRUE; 
            IF AUTO$GO  THEN JOBNAME = XSFW(MSTRRN[0]); 
            FOR K = 0 STEP 1 WHILE JOBINDX EQ 0 DO
            BEGIN 
              IF DIR$NAME[K] EQ SPACES THEN 
                 BEGIN
                   CLR$OPMSG; 
                   OPMSG[0] = "    ------- INVALID SELECTION";
                   OPMSGZB[3] = 0;
                   SENDMSG; 
                   SHOTERM (LOC(OPMSG[0]), 3, TRUE);
                   AUTO$GO = FALSE; 
                   GOTO SJL$SEARCH; 
                 END
              IF DIR$NAME[K] EQ JOBNAME THEN JOBINDX = K + 1; 
              IF (NOT TESTING) AND (NOT AUTO$GO) THEN JOBINDX = 0;
            END 
            IF DIR$TYPE[JOBINDX-1] EQ PTYPE THEN CTLJOB = TRUE; 
            IF DIR$TYPE[JOBINDX-1] EQ JTYPE THEN RUNJOB = TRUE; 
            IF RUNJOB THEN ROUTNAM = JOBNAME; 
          END 
 
          IF OPTION EQ OPTLOAD THEN TBLPTR = DISPCCB; 
          IF CTLJOB THEN NXT2LOD = 1; 
          IF CTLJOB THEN MSTRRN[0] = JOBNAME; 
          IF CTLJOB THEN UPD8MFN; 
        END 
 
        ELSE
        BEGIN 
          FLS2 = JOBNAME; 
          SHOTERM (LOC(FLS0), 4, TRUE); 
          OPTION = OPTDISP; 
          TBLPTR = DISPOPT; 
          NEED$OPRES = TRUE;     #$$$#
          JOBINDX = 0;
        END 
 
  END #SELJOB$LOD#
 
  CONTROL EJECT;
 
# 
 *
 *   PROC SELJOB$SAVE 
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        THIS IS THE CLEAN-UP ROUTINE FOR SAVING A JCL RECORD.  IT IS
 *        CALLED AFTER THE JOB CCL STATEMENTS HAVE BEEN WRITTEN TO THE
 *        ROUTE FILE, AND SETS SEVERAL FLAGS FOR LATER PROCESSING.
 *
 *        CALLS SHOTERM 
 *
# 
 
  PROC SELJOB$SAVE; 
 
  BEGIN 
 
      IF RUNJOB THEN
      BEGIN 
        SHOTERM (LOC(FSV0), 4, TRUE); 
        IF AUTO$GO THEN RDY$4$ROUT = TRUE;
      END 
      OPTION = OPTDISP; 
      TBLPTR = DISPOPT; 
      NEED$OPRES = TRUE;     #$$$#
 
  END #SELJOB$SAVE# 
  CONTROL EJECT;
 
# 
 *
 *   PROC SELJOB$ROUTE
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        THIS IS THE CLEAN-UP ROUTINE FOR ROUTING A JOB TO THE 
 *        INPUT QUEUE.  WHEN CALLED, THE JOB NAME IS ENTERED INTO A 
 *        TABLE (IN COMMON AREA ROUTABL) WHICH IS CHECKED AT THE
 *        TERMINATION OF THE PROGRAM AT WHICH TIME THE FILES ARE
 *        ACTUALLY ROUTED TO THE INPUT QUEUE. 
 *
# 
 
  PROC SELJOB$ROUTE;
 
  BEGIN 
 
    ITEM TEMPR      C(10);
 
    TEMPR = ROUTNAM;
      IF (ROUTYPE EQ 1) AND (SUBSYSNAM NQ SPACES) 
         THEN ROUTNAM = C<0,9>SUBSYSNAM;
 
    ROUTCOD = 0;
    FOR N = 0 STEP 1 WHILE ROUTCOD EQ 0 DO
      BEGIN 
      IF RTFN[N] EQ SPACES THEN 
      BEGIN 
        FILL55 (ROUTNAM); 
        RTFN[N] = ROUTNAM;
        RTFNCD[N] = ROUTYPE;
        RTFNOT[N] = JOBOT;
        RTFNSC[N] = JOBSC;
      END 
      IF RTFN[N] EQ ROUTNAM THEN ROUTCOD = 1; 
      END 
      ROUTNAM = TEMPR;
      IF RT$IMMED THEN ROUT$FILES;
      OPTION = OPTDISP; 
      TBLPTR = DISPOPT; 
      NEED$OPRES = TRUE;     #$$$#
 
  END #SELJOB$ROUTE#
 
  CONTROL EJECT;
 
# 
 *
 *   PROC RLOD$DISP 
 *
 *        CALLED FROM LOAD$JOB, SELJOB$MODIFY 
 *
 *        THE CCL JOB SELECTED BY THE OPERATOR IS SCANNED FOR THOSE 
 *        LINES WHICH ARE PROBABLY CANDIDATES FOR VALUE MODIFICATION. 
 *        THESE LINES ARE MOVED TO THE K/L-DISPLAY BUFFER.
 *
 *        CALLS KEYLINE, INTRACT
 *
# 
 
  PROC RLOD$DISP; 
 
  BEGIN 
 
    J1 = CWC[0];
    N = 0;
    FOR INDX1 = 0 STEP 1 UNTIL INDXC DO 
    BEGIN 
      LIN80[0] = CCLE[INDX1]; 
      IF KEYLINE THEN 
      BEGIN 
        INTRACT (J1, N);
        J1 = N; 
      END 
    END 
 
  END #RLOD$DISP# 
  CONTROL EJECT;
# 
 *
 *   PROC SCAN$CCLS 
 *
 *        CALLED FROM LOAD$JOB, SELJOB$MODIFY 
 *
 *        GIVEN A LINE OF KEY=VAL PAIRS, THIS ROUTINE CHECKS EACH 
 *        LINE IN THE JOB CCL BUFFER AND MAKES ALL THE INDICATED
 *        CHANGES.  THAT IS, THE BUFFER IS SEARCHED FOR ALL OCCURANCES
 *        OF -KEY- AND THESE OCCURANCES ARE REPLACED BY -VAL-.
 *
 *        CALLS CSCAN, GNXT$CCL 
 *
# 
 
  PROC SCAN$CCLS; 
 
  BEGIN 
 
          PACK80 = CMSG80[0]; 
          SETUPC; 
          N2 = 1; 
          REPSIZ[INDXR+N2] = 0; 
          FOR K = 0 STEP 2 WHILE PACKZW[K] NQ 0 DO
          BEGIN 
            REPKEY[INDXR+N2] = PACKW[K];
            REPVAL[INDXR+N2] = PACKW[K+1];
            REPSIZ[INDXR+N2] = 1; 
            REPSIZ[INDXR+N2+1] = 0; 
            N2 = N2 + 1;
          END 
          FOR INDX1= 0 STEP 1 WHILE INDX1 LQ INDXC DO 
          BEGIN 
            PACK80 = CCLE[INDX1]; 
            SETUPC; 
            UPCFLAG = FALSE;
            FOR N1 = (INDXR+1) STEP 1 WHILE REPSIZ[N1] NQ 0 DO
            BEGIN 
              FOR K = 0 STEP 1 WHILE C<0,1>PACKW[K] NQ 0 DO 
              BEGIN 
                IF C<0,7>PACKW[K] EQ C<0,7>REPKEY[N1] THEN
                BEGIN 
                  C<0,7>PACKW[K] = C<0,7>REPVAL[N1];
                  UPCFLAG = TRUE; 
                END 
              END 
            END 
            IF UPCFLAG THEN REPACK; 
            IF UPCFLAG THEN CCLE[INDX1] = PACK80; 
          END 
  END     #SCAN$CCLS# 
  CONTROL EJECT;
 
  PROC REPACK;
 
  BEGIN 
 
    ITEM MORE2DO    B;
    ITEM K1         I;
    ITEM K2         I;
    ITEM K3         I;
 
    PACK80 = SPACES;
    MORE2DO = TRUE; 
    K1 = 0; 
    FOR K2 = 0 STEP 1 WHILE MORE2DO DO
    BEGIN 
      EDITX = PACKW[K2];
      FOR K3 = 0 STEP 1 UNTIL 6 DO
      BEGIN 
        IF C<K3,1>EDITX NQ 0 THEN 
        BEGIN 
          C<K1,1>PACK80 = C<K3,1>EDITX; 
          K1 = K1 +1; 
        END 
      END 
      IF C<9,1>EDITX EQ 0 THEN C<K1,1>PACK80 = " "; 
        ELSE IF C<9,1>EDITX NQ "_"
                          THEN C<K1,1>PACK80 = C<9,1>EDITX; 
      IF PACKZW[K2+1] EQ 0 THEN MORE2DO = FALSE;
      IF C<9,1>EDITX NQ "_" THEN K1 = K1 +1;
    END 
  END     #REPACK LINE# 
 
  CONTROL EJECT;
 
# 
 *   PROC SCAN2$CCLS
# 
  PROC SCAN2$CCLS;
 
  BEGIN 
 
    ITEM INDX       I;
 
    FOR INDX = 0 STEP 1 WHILE INDX LQ INDXC DO
    BEGIN 
      PACK80 = CCLE[INDX];
      SETUPC; 
      UPCFLAG = FALSE;
      FOR N1 = 0 STEP 1 WHILE REPSIZ[N1] NQ 0 DO
      BEGIN 
        FOR K = 0 STEP 1 WHILE PACKZW[K] NQ 0 DO
        BEGIN 
          IF C<0,7>PACKW[K] EQ C<0,7>REPKEY[N1] THEN
          BEGIN 
            C<0,7>PACKW[K] = C<0,7>REPVAL[N1];
            UPCFLAG = TRUE; 
          END 
        END 
      END 
      IF UPCFLAG THEN REPACK; 
      IF UPCFLAG THEN CCLE[INDX] = PACK80;
    END 
 
  END     #SCAN2$CCLS#
 
CONTROL EJECT;
PROC FINDJRC; 
 
      BEGIN 
 
      ITEM I;                # INDEX VARIABLE                          #
 
#     SEARCH FOR JOB RECORD  #
 
 
      DONE = FALSE; 
      JOBFOUND = FALSE; 
      FOR I = 0 STEP 1 WHILE NOT DONE 
      DO
        BEGIN 
        IF DIR$NAME[I] EQ SPACES
        THEN
          DONE = TRUE;
        ELSE IF DIR$NAME[I] EQ JBNAME 
        THEN
          BEGIN 
          JOBFOUND = TRUE;
          DONE = TRUE;
          END 
        END 
 
      END 
CONTROL EJECT;
PROC JNOTF; 
 
# CALLED WHEN JOB RECORD NOT FOUND                                     #
 
      BEGIN 
 
      RDY$2$ROUT = FALSE; 
      CLR$OPMSG;
      OPMSG[0] = " RECORD NOT FOUND - ";
      OPMSG[2] = JBNAME;
      OPMSGZB[3] = 0; 
      SENDMSG;
      SHOTERM(LOC(OPMSG[0]),5,TRUE);
      JOBINDX = 0;
      OPTION = OPTTERM; 
      TBLPTR = DISPOPT; 
      NXT2LOD = 0;
      NETINCR[0] = 0; 
      UPD8NIN;
      NEED$OPRES = TRUE;
      RETURN; 
      END 
  CONTROL EJECT;
# 
 *
 *   PROC LOAD$JOB
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        GIVEN A PARTICUAR JOBNAME (IN THE VARIABLE OF THE SAME NAME), 
 *        THIS ROUTINE EFFECTS THE SEARCH THROUGH THE NETWORK CCL FILE
 *        AND LOADS THE CCL BUFFER WITH THE JOB.
 *
 *        IF THE SELECTED RECORD IS A PARAMETER RECORD, THE JOB EXTRACTION
 *        TABLE IS SET UP FOR ADDITIONAL PASSES THROUGH OUR SYSTEM. 
 *
 *        CALLS FIND$JOB, GETLINE, PRLDNIN, CSCAN, FILL55, SCAN$CCLS
 *              RLOD$DISP.
 *
# 
 
  PROC LOAD$JOB;
 
  BEGIN 
 
        TBLPTR = DISPCCB; 
        P<MSGTBL> = TADR[TBLPTR]; 
        FIRST = TRUE; 
        INDXC = -1; 
        #   CLRTABLE CALL HERE #
        FOR IOCMP = 0 WHILE IOCMP EQ 0 DO 
        BEGIN 
          IF FIRST  THEN
          BEGIN 
            FIND$JOB; 
            LINX[IOCNT-1] = XSFW(LINX[IOCNT-1]);
            IF C<0,2>LINX[0] NQ ".*" THEN INDXC = INDXC + 1;
            IF C<0,2>LINX[0] NQ ".*" THEN CCLE[INDXC] = LIN80[0]; 
            MODFYNDX = 0; 
            IOCMP = 0;
            LDF2 = JOBNAME; 
            OPMSG[0] = LDF; 
            OPMSGZB[3] = 0; 
            SHOTERM (LOC(DATALNS), 4, TRUE);
            SENDMSG;
            FIRST = FALSE;
          END 
          ELSE
          BEGIN     #NOT FIRST# 
            IOCNT = 8;
            IOFWA = LOC(LINX[0]); 
            FOR J2 = 0 STEP 1 UNTIL 9 DO
              LINX[J2] = SPACES;
            GETLINE;
            IF (LIN6[0] EQ "TITLE(") THEN IOCMP = EOR;
            IF IOCMP EQ 0 THEN
            BEGIN 
              LINX[IOCNT-1] = XSFW(LINX[IOCNT-1]);
              IF C<0,2>LINX[0] NQ ".*" THEN INDXC = INDXC + 1;
              IF C<0,2>LINX[0] NQ ".*" THEN CCLE[INDXC] = LIN80[0]; 
            END 
          END 
        END 
 
        IF CTLJOB THEN
        BEGIN 
          EDITX = NETINVN[0]; 
          PRLDNIN;
          INV$INCR = FALSE;     # ASSUME NIP NOT IN JOB LIST #
          NET$START = FALSE;    # AND NOT NETWORK STARTUP    #
          UPIX = -1;
          INDXR = -1; 
          J3 = 0; 
          FOR J2 = 0 STEP 1 WHILE J2 LQ INDXC DO
          BEGIN 
            PACK80 = CCLE[J2];
            FOR K = 0 STEP 1
              WHILE C<K,1>PACK80 NQ C<0,1>PACKEND DO
              BEGIN 
                IF (C<K,1>PACK80 EQ ")") OR 
                   (C<K,1>PACK80 EQ ".") THEN 
                    C<K+1,1>PACK80 = C<0,1>PACKEND; 
              END 
            SETUPC; 
            IF UPCSTAT NQ 0        # IF ANY INVALID PARAMETER(S) FOUND #
               THEN ABORTRUN (101); 
            IF C<0,3>PACKW[0] EQ "JOB" THEN 
            BEGIN 
              IF J3 GQ 200 THEN ABORTRUN(2);
              SCANK = PACKW[1]; 
              SCANV = PACKW[2]; 
              JOBDI = FALSE;
              IF (C<0,2>PACKW[3] EQ "DI" OR 
              C<0,2>PACKW[4] EQ "DI") 
              THEN
                JOBDI = TRUE; 
              IF (RESTRT AND C<0,2>RSAPPL EQ C<0,2>PACKW[2])
              OR (NOT JOBDI AND NOT RESTRT) 
              THEN
              BEGIN 
              FILL55 (SCANK); 
              JBNAME = SCANK; 
              JBL1[J3] = SCANK;     # JOB NAME #
              JBL2[J3] = SCANV;     # ROUTE AND PRODUCT NAME #
              IF C<0,2>SCANV EQ "NI" THEN INV$INCR = TRUE;
              IF C<0,2>SCANV EQ "NI" THEN NET$START = TRUE; 
              IF C<0,2>PACKW[2] EQ C<0,2>PACKW[3]          # SUBSYSTEM #
                 THEN BEGIN                    # PARAM IS SUBSYSTEM ID #
                      JBL3[J3] = PACKW[3];
                      PAKWPTR = 4;
                      END 
                 ELSE PAKWPTR = 3;
              IF JOBDI
                 THEN PAKWPTR = PAKWPTR+1;
              JOBOT = 0;                               # DEFAULT TO SY #
              JOBSC = 0;                          # DEFAULT TO DEFAULT #
              IF PAKWPTR LS UPCOUNT                         # CHECK OT #
                 THEN BEGIN 
                      IF C<0,2>PACKW[PAKWPTR] EQ "SY" 
                         THEN JOBOT = 1;
                         ELSE IF C<0,2>PACKW[PAKWPTR] EQ "BC" 
                              THEN JOBOT = 2; 
                      IF JOBOT EQ 0                       # INVALID OT #
                         THEN ABORTRUN (102); 
                      JOBOT = JOBOT-1;
                      PAKWPTR = PAKWPTR+1;
                      END 
              IF PAKWPTR LS UPCOUNT                         # CHECK SC #
                 THEN BEGIN 
                      IF C<0,2>PACKW[PAKWPTR] EQ "SY" 
                         THEN JOBSC = 1;
                         ELSE IF C<0,2>PACKW[PAKWPTR] EQ "BC" 
                              THEN JOBSC = 2; 
                              ELSE IF C<0,2>PACKW[PAKWPTR] EQ "NS"
                                   THEN JOBSC = 3;
                      IF JOBSC EQ 0                       # INVALID SC #
                         THEN ABORTRUN (103); 
                      IF JOBOT EQ 1                         # OT EQ BC #
                         AND JOBSC NQ 2                     # SC NQ BC #
                         THEN ABORTRUN (104); 
                      PAKWPTR = PAKWPTR+1;
                      END 
              JBL3OT[J3] = JOBOT; 
              JBL3SC[J3] = JOBSC; 
              IF PAKWPTR LS UPCOUNT           # CHECK FOR EXTRA PARAMS #
                 THEN BEGIN 
                      CLR$OPMSG;
                      OPMSG[0] =
                        "WARNING - UNRECOGNIZED EXTRA PARAMETER(S)";
                      OPMSGZB[7] = 0; 
                      SHOTERM (LOC (OPMSG[0]),8,FALSE); 
                      SENDMSG;
                      CLR$OPMSG;
                      FOR K = 0 STEP 1
                          WHILE C<K,1>PACK80 NQ C<0,1>PACKEND DO
                                C<K,1>OPMSG[0] = C<K,1>PACK80;
                      OPMSGZB[7] = 0; 
                      SHOTERM (LOC (OPMSG[0]),8,TRUE);
                      SENDMSG;
                      END 
              J3 = J3 +1; 
              JBL1[J3] = SPACES;
              JBL2[J3] = SPACES;
              JBL3[J3] = SPACES;
              IF RESTRT 
              THEN
                APFOUND = TRUE; 
              END 
            END 
            ELSE IF C<0,5>PACKW[0] EQ "PARAM" THEN  #PARAM RECORD#
            BEGIN 
              UPIX = UPIX +1; 
              IF UPIX GQ 40 THEN ABORTRUN(3); 
              UPARAM[UPIX] = CCLE[J2];
              FOR K = 1 STEP 2 WHILE C<0,1>PACKW[K] NQ 0 DO 
              BEGIN 
                  INDXR = INDXR +1; 
                  IF INDXR GQ 200 THEN ABORTRUN(4); 
                  REPKEY[INDXR] = PACKW[K]; 
                  REPVAL[INDXR] = PACKW[K+1]; 
                  REPSIZ[INDXR] = 1;
                  REPSIZ[INDXR+1] = 0;
              END 
            END 
          END 
        END 
        IF RESTRT AND NOT APFOUND  AND CTLJOB 
        THEN
          BEGIN  # APPL JOB RECORD NOT FOUND                           #
          C<0,3>JBNAME = "JOB";   # PUT THE RESTART RECORD NAME INTO# 
          C<3,7>JBNAME = RSAPPL;  # JBNAME SO THAT JNOTF CAN USE IT # 
          JNOTF;
          RETURN; 
          END 
        IF RESTRT AND APFOUND  AND CTLJOB 
        THEN   # APPL JOB RECORD FOUND IN PARAM RECORD                 #
          BEGIN  # CHECK IF JOB RECORD EXISTS                          #
          FINDJRC;
          APFOUND = FALSE;
          IF NOT JOBFOUND 
          THEN
            BEGIN 
            JNOTF;
            RETURN; 
            END 
          END 
  CONTROL EJECT;
 
        IF RUNJOB THEN
        BEGIN 
          EDITX = ROUTNAM;      #ROUTE AND PRODUCT NAME#
          LIN4SCAN = NCOM80[0]; 
          FOR J2 = 0 STEP 1 UNTIL 178 DO
          BEGIN     #SUBSTITUTE JOB ID IN KEYWORDS# 
            IF C<J2,2>LIN4SCAN EQ "ZZ" THEN 
               C<J2,2>LIN4SCAN = C<0,2>EDITX; 
          END 
          FOR J2 = 0 STEP 1 UNTIL 178 DO
          BEGIN     #SUBSTITUTE NETINV IN FILE NAMES# 
            IF C<J2,3>LIN4SCAN EQ C<0,3>NETINVN[0] THEN 
               C<J2,3>LIN4SCAN = C<4,3>NETINVN[0];
          END 
          C<0,80>PACK80 = C<0,80>LIN4SCAN;
          C<0,100>PACK160 = C<80,100>LIN4SCAN;
          SETUPC2;
          IF XSFW(MSTRUN[0]) NQ SPACES THEN PACKW[4] = MSTRUN[0]; 
          PACKW[6] = MSTRPW[0]; 
          PACKW[8] = MSTROIN[0];
          PACKW[8] = STRIPSP(PACKW[8]); 
          N2 = 1; 
          FOR K = 1 STEP 2 WHILE C<0,1>PACKW[K] NQ 0 DO 
          BEGIN 
            IF (INDXR+N2) GQ 200 THEN ABORTRUN(5);
            REPKEY[INDXR+N2] = PACKW[K];
            REPVAL[INDXR+N2] = PACKW[K+1];
            REPSIZ[INDXR+N2] = 1; 
            REPSIZ[INDXR+N2+1] = 0; 
            N2 = N2 + 1;
          END 
          SCAN2$CCLS; 
        END 
 
        RDY$2$ROUT = TRUE;
        IOFLG = OPTLOAD;
 
        IF INDXC LQ 1 THEN      # RECORD NOT FOUND #
        BEGIN 
          RDY$2$ROUT = FALSE; 
          CLR$OPMSG;
          OPMSG[0] = " RECORD NOT FOUND - ";
          OPMSG[2] = JOBNAME; 
          OPMSGZB[3] = 0; 
          SENDMSG;
          JOBINDX = 0;
          OPTION = OPTDISP;     # SET FOR NEXT SELECTION #
          TBLPTR = DISPOPT; 
          NEED$OPRES = TRUE;
        END 
 
  END   #LOAD$JOB  #
 
  CONTROL EJECT;
 
# 
 *
 *   PROC SAVE$JOB
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        THIS ROUTINE LOOPS THROUGH THE CCL BUFFER, WRITING EACH LINE
 *        TO THE ROUTE FILE.
 *
 *        END OF RECORDS MAY BE WRITTEN AND ARE INDICATED IN THE SOURCE 
 *        FILE BY AN EQUAL SIGN (=) IN THE FIRST CHARACTER POSITION 
 *        OF THE RECORD.
 *
 *        CALLS PUTRTO, PUTRTL, PUTRTR, PUTRTC
 *
# 
 
  PROC SAVE$JOB;
 
  BEGIN 
 
            IF IOFLG EQ 0 THEN
            BEGIN 
              PUTRTO; 
            END 
 
              FOR INDX1 = 0 STEP 1 UNTIL INDXC DO 
              BEGIN 
                IOFWA = LOC(CCLE[INDX1]); 
                IOCNT = 8;
                IF CCL04[INDX1] NQ ".EOR" 
                   THEN BEGIN 
                          PUTRTL; 
                        END 
                   ELSE BEGIN 
                          IF CCL04[INDX1] EQ ".EOR" 
                             THEN BEGIN 
                                      PUTRTR; 
                                  END 
                        END 
              END 
 
              PUTRTR; 
 
            IOFLG = OPTSAVE;
 
            PUTRTC; 
 
 
  END     # SAVE$JOB #
  CONTROL EJECT;
# 
 *
 *   PROC SELJOB$MODFY
 *
 *        CALLED FROM OPTIONLOOP
 *
 *        IF THE MODIFY OPTION HAS BEEN SELECTED BY THE OPERATOR, WE DISPLAY
 *        THE CCL RECORDS MOST LIKELY TO BE MODIFIED AND ALLOW THE OPERATOR 
 *        TO ENTER ONE OR MORE CFO COMMANDS OF THE KEY=VAL VARIETY.  AS EACH
 *        OF THESE COMMANDS ARE ENTERED, WE SCAN THE CCL BUFFER AND 
 *        PERFORM THE REPLACEMENT DISCUSSED ELSEWHERE (SEE SCAN$CCLS).
 *
 *        IF THE COMMAND (CFO.GO.) IS ENTERED, THE JOB IS COPIED TO THE ROUTE 
 *        FILE AND SENT OFF TO THE INPUT QUEUE WITHOUT FURTHER OPERATOR 
 *        INTERVENTION.  OTHERWISE, A SINGLE CFO COMMAND WITH NO DATA (CFO.  )
 *        WILL TERMINATE THIS PROCESSING AND RETURN THE OPERATOR TO THE 
 *        OPTION SELECTION DISPLAY. 
 *
 *        CALLS DISPLAY$L, READ$CFO, SCAN$CCLS, RLOD$DISP, SHOTERM
 *
# 
 
  PROC SELJOB$MODFY;
 
  BEGIN 
 
    ITEM MORE$2$DO  B;
 
      DISPLAY$L;
      RLOD$DISP;
      FOR CSTAT = 1 WHILE CSTAT NQ 0 DO 
      BEGIN 
        MORE$2$DO = TRUE; 
        CSTAT = 4;
        READ$CFO;             # -- CONSOLE INPUT -- # 
        IF CMESS[0] EQ "END.      " THEN CSTAT = 0; 
        IF CMESS[0] EQ "GO.       " THEN
          BEGIN 
            RDY$4$ROUT = TRUE;
            RUNJOB = TRUE;
            CSTAT = 0;
          END 
        IF CSTAT EQ 0 THEN MORE$2$DO = FALSE; 
 
        IF MORE$2$DO THEN SCAN$CCLS;
 
      END     #PROCESS CFO LINES (CSTAT NQ 0)#
 
      RLOD$DISP;
      DISPLAY$L;
      RDY$2$ROUT = TRUE;
      RUNJOB = TRUE;
      DISEND = FALSE; 
      OPTION = OPTDISP; 
      INDX1 = 0;
      INDX3 = 0;
 
      SHOTERM (LOC(UPD8M0), 3, TRUE); 
 
  END #SELJOB$MODFY#
  CONTROL EJECT;
# 
 *
 *   PROC OPTIONLOOP
 *
 *        CALLED FROM NAMIN 
 *
 *        THE CURRENT DEFAULT PARAMETERS ARE DISPLAYED TO THE OPERATOR
 *        AFTER WHICH THE CURRENT OPTION IS PROCESSED VIA CALLS TO THE
 *        APPROPRIATE PROCESSING ROUTINE.  OPTIONS ALLOWED ARE DISPLAY
 *        OF OPTIONS, SELECTION OF PARAMETER OR JOB RECORD, MODIFICATION
 *        OF JOB RECORD, SAVING OF JOB RECORD, ROUTING OF JOB TO INPUT
 *        QUEUE AND TERMINATION OF RUN. 
 *
 *        CALLS DS$DEFAULT, LOAD$JOB, SAVE$JOB, SHOTERM, SELJOB$LOD,
 *              SELJOB$SAVE, SELJOB$ROUTE, SELJOB$MODFY 
 *
# 
 
  PROC OPTIONLOOP;
 
  BEGIN 
 
      INDX2 = 0;
      DISEND = FALSE; 
      IOFLG = 0;
 
      IF (NOT AUTO$GO) THEN DS$DEFAULT; 
 
      P<MSGTBL> = TADR[TBLPTR]; 
 
 
 
      IF (OPTION EQ OPTLOAD) AND (JOBINDX NQ 0) THEN
      BEGIN 
        LOAD$JOB; 
      END 
 
 
 
      IF (OPTION EQ OPTSAVE) AND RUNJOB THEN
      BEGIN 
        SAVE$JOB; 
      END 
 
      IOFLG = 0;
 
 
  CONTROL EJECT;
                                               # MAIN OPTION LOOP   # 
 
 
                 IF OPTION EQ OPTLOAD THEN
            BEGIN 
              SELJOB$LOD; 
            END 
 
            ELSE IF OPTION EQ OPTSAVE THEN
            BEGIN 
              SELJOB$SAVE;
            END 
 
            ELSE IF OPTION EQ OPTSBMT THEN
            BEGIN 
              SELJOB$ROUTE; 
            END 
 
            ELSE IF OPTION EQ OPTMOD THEN 
            BEGIN 
              SELJOB$MODFY; 
            END 
 
            ELSE
            BEGIN 
              TBLPTR = DISPOPT; 
              OPTION = OPTDISP; 
              NEED$OPRES = TRUE;
            END 
 
 
  END #OPTIONLOOP#
 
  CONTROL EJECT;
# 
 *
 *   NAMI   (MAIN PROCESS)
 *
 *        CALLED FROM SYSTEM LOADER 
 *
 *        THE MAIN PROCESSING LOOP WHEREIN WE INITIALIZE NAMI AND 
 *        THEN LOOP BETWEEN GETTING THE NEXT OPERATOR COMMAND (WHICH
 *        CAN BE AUTOMATIC, NOT REQUIRING ACTUAL OPERATOR ACTION) 
 *        AND PROCESSING THAT COMMAND.
 *
 *        UPON RECEIVING THE TERMINATION COMMAND, THE ROUTE-FILE LIST 
 *        IS CHECKED AND FILES ROUTED.  FOLLOWING CLEAN-UP PROCESSING,
 *        THE JOB IS TERMINATED.
 *
 *        CALLS SETUP$NAMI, OPTION$LOOP, GET$NXT$OP, OFLUSH, UPD8MFN, 
 *              CLO$OP$MSG, ROUT$FILES, SENDMSG 
 *
# 
 
      OPMSG[0] = JCAOPMSG[0];          #NAMI CALL STATEMENT            #
      CLEAR$PW;                        #CLEAR PASSWORD ON CALL STMT    #
      SENDMSG;                         #WRITE CALL STATEMENT TO DAYFILE#
 
      CLR$OPMSG;
      OPMSG[0] = IDVERSN; 
      SENDMSG;
 
      SETUP$NAMI; 
 
      FOR OPTION = OPTION WHILE OPTION NQ OPTTERM DO
      BEGIN   #MAIN OPTION LOOP#
 
 
          OPTIONLOOP; 
 
          IF RDY$2$ROUT THEN
          BEGIN 
            TBLPTR = DISPCCB; 
            OPTION = OPTSAVE; 
            NEED$OPRES = FALSE; 
            RDY$2$ROUT = FALSE; 
          END 
          ELSE IF RDY$4$ROUT THEN 
          BEGIN 
            TBLPTR = DISPZRO; 
            OPTION = OPTSBMT; 
            RDY$4$ROUT = FALSE; 
            NEED$OPRES = FALSE; 
          END 
 
          IF NEED$OPRES THEN
          BEGIN 
            GET$NXT$OP; 
          END 
 
 
      END     #MAIN OPTION LOOP#
  CONTROL EJECT;
 
 
      ROUT$FILES; 
 
      OFLUSH; 
      UPD8MFN;
      CLR$OPMSG;
      OPMSG[0] = "      END R7 NAMI"; 
      OPMSGZB[3] = 0; 
      SENDMSG;
 
      SIERRA; 
      NR2 = SIECPUS * 1000.0; 
      NR2 = NR2 + SIECPUMS; 
      NR2 = NR2 - NR1;
      J2 = NR2; 
      EDITX = XCFD(J2); 
      OPMSG[0] = "     CPU  MS  REQD  ";
      OPMSG1[2] = EDITX;
      OPMSGZB[3] = 0; 
      SENDMSG;
      SHOTERM (LOC(OPMSG[0]), 3, TRUE); 
 
      OFLUSH; 
      FINSHIO;
 
 
      IF START$SUBS AND NOT RESTRT THEN 
      BEGIN 
        ROUTYPE = 0;
        IF TESTING THEN ROUTYPE = 4095; 
        ROUTNAM = RTFN[INDXC];
        ROUTCOD = ROUTIQ + ROUTNIP ;
        ROUTEM; 
      END 
 
 
 
  END #NAMI#
 
  TERM
*CWEOR,0