*DECK,SCH 
USETEXT TCH$COM 
USETEXT MISC$ 
USETEXT GLOBALI 
USETEXT CHN$COM 
USETEXT RBF$COM 
USETEXT ACN$COM 
USETEXT CMD$COM 
USETEXT DCB$COM 
USETEXT IP$COM
USETEXT TCB$COM 
USETEXT TSB$COM 
USETEXT UCB$COM 
  
      PROC SCH; 
      BEGIN # SCH # 
*IF DEF,IMS 
 #
*1DC  SCH 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        SCH                 SEYUNG OH           OCT 25,1979
* 
*     2. FUNCTIONAL DESCRIPTION 
*        SCH IS THE MAIN MODULE OF RBF. IT CONTROLS CALLS TO MODULES, 
*        ACQUIRES DATA FROM THE NETWORK, CALLS FOR BUFFER MANAGEMENT
*        TO REORGANISE BUFFER SPACE AS IS NECESSARY AND INSTIGATES
*        ROLLOUT WHEN POSSIBLE. 
* 
*     3. METHOD USED
*        CALL GETDATA TO GET ALL DATA/SMS FOR RBF.
*        CHECK IF NETREL NEEDS TO BE CALLED TO FLUSH NETWORK DEBUG LOG
*          FILE.
*        CHECK IF ROLL/NOROLL CFO COMMAND HAS BEEN ENTERED AND
*          PROCESSED ACCORDINGLY. 
*        UPDATE CURRENT CLOCK TIME. 
*        CALL TMOPROC EVERY 7 SECONDS TO SCAN THE ACN TABLE 
*          FOR INACTIVE TERMINALS.
*        CALL CHOOSE TO PROCESS EVENT CHAIN AND SCAN FOR ACTIVE 
*          TERMINALS TO PROCESS.
*        LOAD AND EXECUTE OVERLAY TO UPDATE K DISPLAY.
*        CALL NETCHEK TO UPDATE NSUP WORD AND TO TRANSFER WORKLIST IF 
*          ONE NEEDS TO BE SENT.
*        IF PP CALLS OUTSTANDING, DELAY FOR SHORT PERIOD OF TIME AND
*          THEN GO BACK AND RESTART PROCESSING WITH CFO COMMAND 
*          CHECKING.
*        IF NAM HAS DATA OR SMS FOR RBF, GO BACK TO BEGINNING.
*        CHECK FOR ENTRIES IN BACKGROUND CHAIN.  IF SO DELAY FOR 2
*          SECONDS BY ISSUEING NETWAIT CALL.  THEN PROCESS THE
*          BACKGROUND CHAIN AND GO BACK TO THE BEGINNING. 
*        IF TIME FOR IT, CALL XFLMGR TO REORGANIZE BUFFER SPACE.
*        CALL ROLLOUT TO ROLLOUT FIELD LENGTH FOR SHORT TIME PERIOD.
*        GO BACK TO BEGINNING.
* 
*     4. ENTRY PARAMETERS. NONE.
* 
*     5. EXIT PARAMETERS. NONE. 
* 
*     6. COMDECKS USED
*        RBF$COM
*        ACN$COM
*        CHN$COM
*        CMD$COM
*        DCB$COM
*        GLOBALI
*        IP$COM 
*        MISC$
*        TCH$COM
*        TSB$COM
*        UCB$COM
*        TCB$COM
*        TSBMDEFS 
*        TSBMBASE 
* 
*     7. ROUTINES CALLED. 
*        GETDATA
*        LOADX               LOAD AND EXECUTE OVERLAY 
*        NETCHEK             FORCE WORKLIST TRANSFER IF ANY 
*        NETREL              RELEASE NETWORK DEBUG LOG FILE 
*        NETWAIT             ISSUE NETWAIT CALL 
*        PROCESS             PROCESS ENTRIES IN CHAIN 
*        UPDATE 
*        CHOOSE 
*        XFLMGR 
*        ROLLOUT
*        SYSCALL
* 
*     8. DAYFILE MESSAGES. NONE.
* 
 #
*ENDIF
  
      XREF PROC GETDATA;     # ACQUIRE NETWORK DATA                    #
      XREF PROC CHOOSE;      # CHOOSE CHAIN, PROCESS IT, BACKGROUND CHN#
      XREF PROC XFLMGR;      # REORGANIZE BUFFERS AND FREE UNUSED MEM. #
      XREF PROC ROLLOUT;     # ROLL OUT IF POSSIBLE, EXECUTE NETWAIT   #
      XREF PROC NETCHEK;               # TRANSFER WORK LIST TO NAM     #
      XREF PROC NETREL;      # RELEASE NETWORK DEBUG LOG FILE          #
      XREF PROC NETWAIT;     # ISSUE NETWAIT CALL # 
      XREF PROC PROCESS;
      XREF PROC SYSCALL;
      XREF PROC LOADX; # LOAD OVERLAY AND EXECUTE # 
      XREF FUNC GETBUF U;    # GET TSB BUFFER                          #
      XREF FUNC DIFFER;      # MAGNITUDE DIFFERENCE FUNCTION           #
      XREF ITEM PRIMARY U;
      XREF ITEM SECOND  U;
      XREF ITEM NEWTIM I; 
      XREF ITEM OLDTIM I; 
      XDEF ITEM ROLL B = TRUE;                   # ROLL OUT CM FLAG    #
      XREF ARRAY RBFKDS [0:0] S(1); # K-DISPLAY CONTROL WORD           #
        BEGIN 
        ITEM KSIZE B(00,10,01);# K-DISPLAY CHARACTER SIZE              #
        ITEM KFORM B(00,11,01);# K-DISPLAY LINE FORMAT                 #
        ITEM KDISP B(00,59,01);# DISPLAY COMPLETE FLAG (SET BY DSD)    #
        END 
      ITEM LOOPCT I = 0;     # LOOP COUNT TO CALL XFLMGR          # 
      ITEM NRFLFN = O"16220634000000000000";  # NETWORK RELEASE FILE   #
      DEF SYSTIME # O" 5 00 000000" #;           # RTIME REQUEST       #
      ITEM LOOPMAX I = O"100";
      ITEM TIME3 I = 0;                          # INACTIVITY TIMER    #
#                                                                      #
      CONTROL EJECT;
      PROC TMOPROC; 
      BEGIN                                      # TMOPROC             #
 #
*1DC  TMOPROC 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        TMOPROC             A. L. TURKE         JAN 10, 1983 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        TMOPROC IS ACTIVATED EVERY 7 SECONDS BY A DIRECT CALL FROM 
*        SCH, THE RBF MAIN SCHEDULER.  TMOPROC SCANS THE ENTIRE 
*        ACN TABLE DURING EACH EXECUTION.  CONSOLE ACN ENTRIES ARE
*        PROCESSED TO SEE IF ANY OF THEIR ASSOCIATED PASSIVE DEVICES
*        ARE ACTIVE.  A CONSOLE ACN IS CONSIDERED ACTIVE IF ONE OR
*        MORE OF ITS PASSIVE DEVICES ARE ACTIVE.  PASSIVE DEVICES 
*        ARE CONSIDERED ACTIVE IF THEY ARE ENGAGED IN UPLINE OR 
*        DOWNLINE FILE TRANSMISSION.  SPECIFICALLY, AN UPLINE DEVICE
*        IS CONSIDERED ACTIVE WHEN- 
* 
*             TCB$NOTRDY IS FALSE 
*                    AND
*             UCB$FILEACT IS TRUE 
* 
*        A DOWNLINE DEVICE IS CONSIDERED ACTIVE WHEN- 
* 
*             TCB$NOTRDY IS FALSE 
*                    AND
*             DCB$FILEACT IS TRUE 
* 
*        A TIMER, TCB$ALOTIME, IS MAINTAINED IN THE TERMINAL CONTROL
*        BLOCK AS FOLLOWS-
* 
*        1) IF THE CONSOLE ACN IS FOUND TO BE ACTIVE THEN 
*           TCB$ALOTIME IS SET TO ZERO. 
* 
*        2) IF THE CONSOLE ACN IS FOUND TO BE INACTIVE AND TCB$ALOTIME
*           IS ZERO THEN
*           TCB$ALOTIME IS SET TO THE CURRENT TIME WHICH IS AVAILABLE IN
*           GLOBAL CELL "CLOCK".
* 
*     3. METHOD USED. 
*        A TERMINAL IS TIMED OUT OF RBF WHEN ITS INACTIVITY TIMER 
*        EXPIRES. TCB$ALOTIME EXPIRES WHEN THE DIFFERENCE BETWEEN ITS 
*        VALUE AND THE CURRENT CLOCK TIME EXCEEDS INSTALLATION
*        VARIANT TIMEOUT VALUE, ALOTIME (DEFINED IN COMMON DECK IP$COM) 
* 
*        THE TIMEOUT INVOLVES A SOFTWARE GENERATED "END" COMMAND FOR
*        THE TERMINAL.  THE TERMINAL IS THEN SWITCHED TO NVF AND
*        WILL BE DISCONNECTED WHEN AND IF THE NVF TIMER EXPIRES.
* 
*     4. ENTRY PARAMETERS.
*        NONE.
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. SYMPLTEXTS USED. 
*        TCH$COM
*        TSB$COM
*        ACN$COM
*        IP$COM 
*        TCB$COM
*        DCB$COM
*        CMD$COM
*        UCB$COM
* 
*     7. ROUTINES USED. 
*        DIFFER - MAGNITUDE DIFFERENCE FUNCTION 
* 
*        GETBUF - GET TSB BUFFER
* 
*     8. DAYFILE MESSAGES.
*        NONE.
* 
 #
  
      ITEM I1,I2;            # INDEX VARIABLES                         #
      ITEM ACTIVE B;         # ACTIVE TERMINAL FLAG                    #
      ITEM CITBUFR U;        # CIT BUFFER ORDINAL                      #
  
      FOR I1 = LOWER$ACN STEP 1 UNTIL UPPER$ACN -2 DO 
        BEGIN                # CYCLE THROUGH CONNECTIONS               #
        IF ACN$DEVTYPE [I1] EQ S"CONSOLE" AND 
           ACN$STATE[I1] EQ S"ACTIVE" 
        THEN                 # CONSOLE CONNECTION                      #
          BEGIN 
          P<TCB> = ADDRESS[ACN$CB[I1]]; 
          P<TCB$DEVICE> = P<TCB> + TCB$SIZE;
          ACTIVE = FALSE; 
          FOR I2 = 1 STEP 1 WHILE I2 LQ TCB$NDEVICE AND NOT ACTIVE DO 
            BEGIN            # SEARCH FOR AN ACTIVE DEVICE             #
            IF TCB$DEVDT[I2] EQ DEVICETYPE"CARD$READER" 
            THEN
              BEGIN          # INPUT DEVICE                            #
              IF ACN$CB[TCB$DEVACN[I2]] NQ 0
              THEN
                BEGIN 
                P<UCB> = ADDRESS[ACN$CB[TCB$DEVACN[I2]]]; 
                ACTIVE = UCB$FILEACT AND NOT TCB$NOTRDY[I2];
                END 
              END            # INPUT DEVICE                            #
            ELSE
              BEGIN          # OUTPUT DEVICE                           #
              IF ACN$CB[TCB$DEVACN[I2]] NQ 0
              THEN
                BEGIN 
                P<DCB> = ADDRESS[ACN$CB[TCB$DEVACN[I2]]]; 
                ACTIVE = DCB$FILEACT AND NOT TCB$NOTRDY[I2];
                END 
              END            # OUTPUT DEVICE                           #
            END              # SEARCH FOR AN ACTIVE DEVICE             #
          IF TCB$HWFLAG 
          THEN               # HARDWIRED TERMINAL                      #
            ACTIVE = TRUE;   # FORCE HARDWIRED TERMINAL ACTIVE         #
          ACTIVE = ACTIVE OR TCB$IAFFLAG; 
          ACTIVE = ACTIVE OR TCB$CTIM;        # IF NO TERMINAL TIMEOUT #
          IF ACTIVE 
          THEN
            TCB$ALOTIME = 0;
          ELSE
            BEGIN            # INACTIVE TERMINAL FOUND                 #
            IF TCB$ALOTIME EQ 0 
            THEN
              TCB$ALOTIME = CLOCK;
            ELSE
              BEGIN          # TIMEOUT CHECK                           #
              IF DIFFER (TCB$ALOTIME,CLOCK) GR ALOTIME
              AND TCB$CITBUF EQ 0 AND NOT TCB$ALOFLAG 
              THEN
                BEGIN        # TERMINAL AUTO-LOGOUT                    #
                CITBUFR = GETBUF(CIT$SIZE,MOVEABLE);  # GET CIT BUFFER #
                IF CITBUFR NQ 0 
                THEN
                  BEGIN      # CIT BUFFER SPACE AVAILABLE              #
                  P<TCB> = ADDRESS[ACN$CB[I1]]; 
                  TCB$CITBUF = CITBUFR;  # LINK CIT TO TCB             #
                  TCB$ALOFLAG = TRUE;    # SET AUTO-LOGOUT TRUE        #
                  P<CIT$TABLE> = ADDRESS[CITBUFR];
                  CIT$CMDTYPE = S"END"; 
                  END        # CIT BUFFER SPACE AVAILABLE              #
                END          # TEMINAL AUTO-LOGOUT                     #
              END            # TIMEOUT CHECK                           #
            END              # INACTIVE TERMINAL FOUND                 #
          END                # CONSOLE CONNECTION                      #
        END                  # CYCLE THROUGH CONNECTIONS               #
      RETURN; 
      END                    # TMOPROC                                 #
      CONTROL EJECT;
OUTSTART: 
                                           #START OUTER  LOOP TIMER    #
# # 
      GETDATA;                             #NETGETL UNTIL NULL BLOCK   #
SERVICE:  
      IF MC NQ 0 AND NSUP$NMSG[0] GQ MC 
      THEN                   # TOO MANY MSGS IN ZZZZZDN - TIME TO FLUSH#
        BEGIN 
        NETREL(NRFLFN,0,0);  # FLUSH NETWORK DEBUG LOG FILE            #
        END 
      IF TESTCFO
      THEN
        BEGIN 
        IF C<0,6>CFOMESSAGE EQ "NOROLL" 
        THEN
          BEGIN 
          ROLL = FALSE; 
          END 
        IF C<0,4>CFOMESSAGE EQ "ROLL" 
        THEN
          BEGIN 
          ROLL = TRUE;
          END 
        CFOMESSAGE = ZERO;
        ENABLECFO;
        END 
      SYSACT = FALSE; 
      SYSCALL("TIMP",SYSTIME + LOC (CLOCK));
      CLOCK = B<0,24>CLOCK LAN O"7777"; 
      IF ((CLOCK - TIME3) LAN O"7777" GR O"7") AND (ALOTIME NQ 0) THEN
        BEGIN 
          TMOPROC;           # PROCESS INACTIVE TERMINAL SCAN          #
          TIME3 = CLOCK;
        END 
      CHOOSE;                              #PROCESS THE OVERLAY CHAINS #
     IF KDISP 
     THEN 
       BEGIN # UPDATE K-DISPLAY # 
        PRIMARY = 1;
        SECOND = 13;
        LOADX;
        END 
      NETCHEK;                                   # TRANSFER WORK LIST  #
      LOOPCT = LOOPCT + 1;                       # INCREMENT LOOP CNT  #
      IF SYSACT THEN
        BEGIN                              #WAIT FOR EXT ACTIVITY      #
        SYSCALL("RCL",0);                        # WAIT PP COMPLETE    #
        SYSCALL("RCL",0); 
        SYSCALL("RCL",0); 
        GOTO SERVICE; 
        END 
      SYSCALL("RCL",0); 
      IF LOOPCT GQ LOOPMAX         # CHECK IF TIME TO CALL XFLMGR      #
      THEN
        BEGIN 
        XFLMGR; 
        LOOPCT = 0;                # RE-INITIALIZE LOOP COUNT          #
        END 
      IF CHN$NENTRIES[CHAINS"BACKGROUND"] NQ ZERO 
      THEN                   # DELAY 2 SECONDS #
        BEGIN 
        NETWAIT(2,0);        # ISSUE NONFORCED NETWAIT FOR 2 SECONDS #
        PROCESS(CHAINS"BACKGROUND");  # PROCESS BACKGROUND CHAIN #
        NEWTIM = OLDTIM;           # RESET NEWTIM # 
        GOTO OUTSTART;       # RESTART AT BEGINNING # 
  
        END 
      ROLLOUT;                                   # ROLL OUT            #
      GOTO OUTSTART;
      END # SCH # 
      TERM; 
