*COMDECK PBQUEMAIN
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        P G Q U E M A I N T   -   MAINTAIN DOWNLINE TCB QUEUE        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$G-,R-,I-    NON RECURSIVE, INTERRUPTABLE ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE MAINTAINS THE DOWNLINE TCB QUEUE         * 
*             BY ADDING BLOCKS TO THE FRONT OR THE END OF THE QUEUE,  * 
*             OR BY REMOVING TOP ENTRIES FROM THE QUEUE. UNDER        * 
*             CERTAIN CONDITIONS, A CHECK IS MADE TO SEE IF U/L       * 
*             BACK(S) ARE DUE AND NEED TO BE SENT NOW.                * 
*             THIS PROCEDURE ALSO MAINTAINS THE D/L BATCH ACCOUNTING  * 
*             COUNTERS AND CHECKS FOR PM MESSAGES IN THE LP STREAMS   * 
*                                                                     * 
** INPUT    - B1TCB, B1BUFF TCB POINTER, BUFFER POINTER,              * 
*             QUEUE ACTION (PARAMETER)                                * 
*             THE FOLLOWING QUEUE ACTIONS ARE DEFINED:                * 
*               K4GET   - GET TOP ENTRY, TEST FOR BACKS DUE           * 
*               K4GETNB - GET TOP ENTRY, DONT TEST FOR BACKS DUE      * 
*               K4PUT   - PUT AT END OF QUEUE, BACK TEST ON EMPTY QUE * 
*               K4PUTFR - PUT AT FRONT OF QUEUE, BACK TEST ON EMPTY Q * 
*               K4PUTBC - PUT AT END OF QUEUE, FORCE BACK TEST        * 
*                         (THE PUT POINTER MAY BE NIL)                * 
*                                                                     * 
** OUTPUT   - ON ACTION GET, THE POINTER IS RETURNED IN B1BUFF        * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBTIPWLE    - BUILD/SEND A0QUEOUT WLE TO THE TIP        * 
*             PBRELCHN    - RELEASE CHAIN OF BUFFERS                  * 
*             PBGET1BF    - GET A BUFFER (TO SEND U/L CMD)            * 
*             PBBACKCHECK - PERFORM U/L BACK CHECK, SEND BACK(S)      * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PGQUEMAINT (K4ACTION : INTEGER);
  
LABEL 
  99;                                       _PBQUEMAINT EXIT           ?
  
CONST 
  K4LIMIT   = 0;                            _MAX. NO OF INTERNAL MSG(S)?
  
VAR 
  K4QUEUE   : 'B0BUFPTR;                    _QUEUE POINTER POINTER     ?
  K4WQUEUE  : 'B0BUFPTR;                    _WORK QUEUE POINTER POINTER?
  K4ACTL8   : INTEGER;                      _ACCOUNT WORK VARIABLE     ?
  K4BACKCHK : BOOLEAN;                      _BACK CHECK TEST FLAG      ?
  K4WPTR    : B0BUFPTR;                     _WORK POINTER              ?
  K4CNT     : INTEGER;                      _COUNT OF INTERNAL MSG(S)  ?
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        B P B U I L D C M D   -   BUILD / SEND UPLINE COMMANDS       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE BUILDS AND SENDS COMMANDS FOR BATCH      * 
*             STREAMS. THE COMMANDS THAT ARE BUILT ARE:               * 
*               OUTPUT STOPPED BECAUSE OF FILE LIMIT REACHED          * 
*               OUTPUT STOPPED BECAUSE PM MESSAGE RECOGNIZED          * 
*                                                                     * 
** INPUT    - SECONDARY FUNCTION CODE (SCF) (PARAMETER)               * 
*                                                                     * 
** OUTPUT   - CMD SEND UPLINE                                         * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBUBPM      - PASS CMD UPLINE                           * 
*                                                                     * 
** NOTE     - THIS ROUTINE DOES NOT RETURN TO ITS CALLER, BUT         * 
*             RETURNS TO THE CALLER OF PGQUEMAINT IMMEDIATELY         * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE BPBUILDCMD (K4SFC : INTEGER); 
  
BEGIN 
B1BUFF'.BIINT [PFC/2+1] := D8OS * $100 +    _INSERT PFC/SFC            ?
                           K4SFC; 
B1BUFF'.BFFCD           := PFC;             _INSERT FCD                ?
B1TCB'.BSTCB.BSSTSTOP   := TRUE;            _DECLARE STREAM STOPPED    ?
PBUBPM (B1BUFF, HTCMD);                     _SEND COMMAND U/L          ?
B1BUFF                  := NIL;             _RETURN NIL PTR TO CALLER  ?
GOTO EXIT 99;                               _EXIT IMMEDIATELY          ?
END;  _PROCEDURE BPBUILDCMD?
_$J+? 
_*****************************
*                            *
*    BEGIN QUEUE MAINTENANCE *
*                            *
*****************************?
BEGIN 
WITH B1TCB'.BSTCB DO                        _INDEX TO TCB              ?
  BEGIN 
  ADDR (BSQPTR, K4QUEUE);                   _GET ADDRESS OF D/L QUEUE  ?
  IF K4ACTION \ K4PUT 
  THEN
_ 
* * * *  ACTION IS PUT IN QUEUE 
? 
    BEGIN 
    IF B1BUFF " NIL                         _DATA PASSED TO PUT IN QUE ?
    THEN
      BEGIN 
      IF K4QUEUE' = NIL                     _PUT IN EMPTY QUEUE        ?
      THEN
_ 
* * * *  SEND WLE TO TIP ON PUT IN EMPTY D/L QUEUE
? 
        PBTIPWLE
      ELSE                                  _QUEUE IS NOT EMPTY        ?
_ 
* * * *  PUT IN NOT EMPTY QUEUE (AT END OR IN FRONT OF QUEUE) 
? 
        BEGIN 
        K4WQUEUE := K4QUEUE;                _SET WORK QUEUE POINTER    ?
        K4CNT    := 0;                      _CLEAR INTERNAL COUNT      ?
        REPEAT
          ADDR (K4WQUEUE''.BCCHAINS [QCHN], 
                K4WQUEUE);                  _GET NEXT ENTRY ADDR IN QUE?
          IF K4ACTION " K4PUTFR 
          THEN                              _ACTION IS PUT AT END OF Q ?
            K4QUEUE := K4WQUEUE             _ADVANCE QUEUE PTR         ?
          ELSE
            IF K4QUEUE''.BFINTBLK           _ACTION IS PUT AT FRONT Q  ?
            THEN                            _THEN QUEUE AFTER INTBLKS  ?
              BEGIN 
              K4CNT := K4CNT + 1;           _COUNT INTERNAL MESSAGES   ?
              IF K4CNT > K4LIMIT            _IF .GT. THAN MAX.         ?
              THEN
                BEGIN 
                K4WPTR := BSQPTR.BABUFPTR;  _GET OLDEST MESSAGE        ?
                BSQPTR.BABUFPTR := BSQPTR.  _ADVANCE TO NEXT OLDEST    ?
                  BABUFPTR'.BCCHAINS[QCHN]; 
                PBRELCHN (K4WPTR,BEDBSIZE); _RELEASE FIRST MESSAGE     ?
                END; _ K4CNT > K4LIMIT ?
              END; _ BFINTBLK ? 
        UNTIL K4WQUEUE' = NIL;              _UNTIL END OF QUEUE        ?
        END;
      B1BUFF'.BCCHAINS [QCHN] := K4QUEUE';  _POSSIBLE REST Q IN NEW ENT?
      K4QUEUE'  := B1BUFF;                  _INSERT NEW ENTRY IN QUEUE ?
      B1BUFF    := NIL;                     _RETURN ZERO PTR TO CALLER ?
      END; _IF B1BUFF " NIL THEN? 
    IF BSQPTR.BABUFPTR = NIL
    THEN                                    _QUEUE EMPTY AFTER NIL PUT ?
      K4BACKCHK := TRUE;                    _THEN CHECK FOR U/L BACK   ?
    IF K4ACTION = K4PUTBC 
    THEN                                    _PUT WITH FORCED BACK CHECK?
      K4BACKCHK := TRUE;
    END _IF K4ACTION \ K4PUT THEN?
  ELSE
_ 
* * * *  ACTION IS TAKE FROM QUEUE
? 
    BEGIN 
    IF BSSTSTOP 
    THEN                                    _STREAM IS STOPPED         ?
      B1BUFF := NIL                         _RETURN NIL POINTER        ?
    ELSE
      BEGIN 
      B1BUFF := K4QUEUE';                   _GET TOP ENTRY OF QUEUE    ?
                                            _WITHOUT ACTUALLY DEQUEUING?
      IF B1BUFF " NIL 
      THEN                                  _QUEUE IS NOT EMPTY        ?
        BEGIN 
        IF BSBATCH
        THEN
          BEGIN                             _BATCH STREAM,             ?
          IF B1BUFF'.BFPMMSG                _PM MESSAGE FOUND          ?
          THEN
_ 
* * * *  FOUND PM MESSAGE IN BATCH QUEUE
? 
            BEGIN 
            K4QUEUE' := B1BUFF'.
                        BCCHAINS [QCHN];    _DEQUEUE THE PM MESSAGE    ?
            BPBUILDCMD (D9PM);              _AND SHIP IT UPLINE        ?
                                            _NOTE: BPBUILDCMD EXITS    ?
            END; _IF BFPMMSG? 
_ 
* * * *  BATCH DATA, PERFORM ACCOUNTING LOGIC 
? 
          K4ACTL8  := BSACTL8 + 
                      B1BUFF'.BIINT [4];    _ADD ACCOUNTING DATA       ?
          BSACTL8  := K4ACTL8;              _STORE LOWER 8             ?
          BSACTH16 := K4ACTL8 / 256 +       _AND UPPER 16 BITS         ?
                      BSACTH16; 
          IF BSALIMIT " 0 
          THEN                              _TEST FOR ACCOUNTING LIMIT ?
            IF BSALIMIT - BSACTH16 < 1
            THEN                            _ACCOUNTING LIMIT REACHED  ?
_ 
* * * *  ACCOUNTING LIMIT HAS BEEN REACHED
? 
              BEGIN 
              B1BUFF'.BIINT [4] := 0;       _CLEAR ACC FOR THIS BLOCK  ?
              B1BUFF            :=
                PBGET1BF (BEDBSIZE);        _GET BUFFER FOR U/L CMD    ?
              B1BUFF'.BFLCD     := SFC;     _INSERT LCD                ?
              BPBUILDCMD (D9FLF);           _SEND LIMIT REACHED U/L    ?
                                            _NOTE: BPBUILDCMD EXITS    ?
              END;
          END; _IF BSBATCH? 
        K4QUEUE' := B1BUFF'.BCCHAINS [QCHN];_NOW DEQUEUE TOP ENTRY     ?
        END; _IF B1BUFF " NIL?
      IF K4ACTION " K4GETNB 
      THEN                                  _ACTION IS NOT GET WITHOUT ?
        K4BACKCHK := TRUE;                  _BACK CHECK, DO CHECK      ?
      END; _IF BSSTSTOP ELSE? 
    END; _IF K4ACTION \ K4PUT ELSE? 
  END; _WITH B1TCB'.BSTCB DO? 
_ 
* * * *  TEST FOR UPLINE BACK DUE 
? 
IF K4BACKCHK
THEN                                        _TEST FOR U/L BACK DUE REQ ?
  BEGIN 
  PBBACKCHECK;                              _PERFORM U/L BACK CHECK    ?
  K4BACKCHK := FALSE; 
  END;
  
99: 
END;  _PROCEDURE PGQUEMAINT?
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        P B Q U E M A I N T   -   PAGE SWITCHER FOR PGQUEMAINT       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$G-,R-,I-    NON RECURSIVE, INTERRUPTABLE ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE SETS UP THE GLOBAL TCB AND BUFFER        * 
*             POINTERS AND TRANSFERS CONTROL TO THE PAGED ROUTINE     * 
*             PGQUEMAINT (SAVING THE CALLERS PAGE NUMBER)             * 
*                                                                     * 
** INPUT    - K4TCBP  POINTER TO TCB, K4BLKP  POINTER TO BUFFER       * 
*             K4ACTION  QUEUE ACTION (ALL PARAMETERS)                 * 
*                                                                     * 
** OUTPUT   - TOP BUFFER TAKEN FROM DOWNLINE QUEUE, OR BUFFER         * 
*             ADDED TO FRONT OR END OF DOWNLINE QUEUE                 * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBRDPGE     - SAVE CALLERS PAGE NUMBER                  * 
*             PBPSWITCH   - SWITCH TO NEW (BIPS) PAGE NUMBER          * 
*             PGQUEMAINT  - PAGED QUEUE MAINTENANCE ROUTINE           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PBQUEMAINT (K4TCBP : B0BUFPTR; VAR K4BLKP : B0BUFPTR; 
                      K4ACTION : INTEGER);
  
VAR 
  K4OLDPG : INTEGER;                        _CALLERS PAGE NUMBER       ?
  
BEGIN 
B1TCB      := K4TCBP;                       _SET GLOBAL TCB AND        ?
B1BUFF     := K4BLKP;                       _BUFFER POINTERS           ?
PBRDPGE    (K4OLDPG);                       _SAVE CALLERS PAGE         ?
PBPSWITCH  (K0PGBIP);                       _SWITCH TO BIPS PAGE       ?
PGQUEMAINT (K4ACTION);                      _CALLED PAGED ROUTINE      ?
PBPSWITCH  (K4OLDPG);                       _RESTORE CALLERS PAGE      ?
K4BLKP     := B1BUFF;                       _RETURN PTR TO CALLER      ?
END;  _PROCEDURE PBQUEMAINT?
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        P G P U R G E Q U E   -   PURGE UP AND/OR DOWNLINE QUEUE     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$G-,R-,I-    NON RECURSIVE, INTERRUPTABLE ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE PURGES THE UPLINE AND/OR THE DOWNLINE    * 
*             DATA QUEUES IN THE TCB, AND CLEARS RELATED UPLINE       * 
*             AND/OR DOWNLINE QUEUE CONTROL FIELDS                    * 
*                                                                     * 
** INPUT    - B1TCB POINTER TO THE TCB, INDICATION OF WHICH QUEUE     * 
*             MUST BE PURGED (PARAMETER)                              * 
*                                                                     * 
** OUTPUT   - REQUESTED QUEUE(S) PURGED                               * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBRELZRO    - RELEASE POSSIBLE CHAIN OF BUFFERS         * 
*             PBBACKCHECK - FLUSH U/L BACKS ON D/L QUEUE PURGE        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PGPURGEQUE (K4DIRECT : INTEGER);
  
VAR 
  K4BUFP  : B0BUFPTR;                       _ LOCAL VARIABLE           ?
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        B P R E L Q U E   -   RELEASE DATA FROM GIVEN QUEUE          * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THE PROCEDURE RELEASES THE DATA FROM THE GIVEN QUEUE    * 
*                                                                     * 
** INPUT    - POINTER TO QUEUE TO BE RELEASED (PARAMETER)             * 
*                                                                     * 
** OUTPUT   - QUEUE RELEASED                                          * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBRELZRO    - RELEASE POSSIBLE CHAIN OF BUFFERS         * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE BPRELQUE (VAR K4QUEUE : B0BUFPTR);
BEGIN 
  WHILE K4QUEUE  " NIL DO                   _ LOOP ON QUEUES           ?
  BEGIN 
    K4BUFP   := K4QUEUE;                    _ GET BUFFER TO BE RELEASE ?
    K4QUEUE  := K4BUFP'.BCCHAINS[QCHN];     _ UPDATE QUEUE POINTER     ?
    PBRELZRO (K4BUFP, BEDBSIZE);            _ RELEASE BUFFERS          ?
  END;
END;  _ PROCEDURE BPRELQUE? 
_$J+? 
_*****************************
*                            *
*    BEGIN PURGE QUEUE       *
*                            *
*****************************?
BEGIN 
IF K4DIRECT \ K4BOTH
THEN
_ 
* * * *  PURGE UPLINE QUEUES
? 
  BEGIN 
  BPRELQUE (B1TCB'.BSTCB.BSFULLQ.BABUFPTR); 
  PBRELZRO (B1TCB'.BSTCB.BSWORKQUE, BEDBSIZE);
  B1TCB'.BSTCB.BSOBCNT := 0;                _CLEAR OUTSTANDING BLK CNT ?
  END;
  
IF K4DIRECT @ K4BOTH
THEN
_ 
* * * *  PURGE DOWNLINE QUEUE 
? 
  BEGIN 
  BPRELQUE (B1TCB'.BSTCB.BSQPTR.BABUFPTR);
  B1TCB'.BSTCB.BSSTSTOP := FALSE;           _CLEAR STREAM STOPPED      ?
  B1TCB'.BSTCB.BSWTOMRK := FALSE;           _CLEAR WAITING FOR MARKER  ?
  PBBACKCHECK;                              _SEND ALL U/L BACKS DUE    ?
  END;
END; _PROCEDURE PGPURGEQUE? 
  
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        P B P U R G E Q U E   -   PAGE SWITCHER FOR PGPURGEQUE       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$G-,R-,I-    NON RECURSIVE, INTERRUPTABLE ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE SETS UP THE GLOBAL TCB POINTER AND       * 
*             TRANSFERS CONTROL TO THE PAGED ROUTINE PGPURGEQUE       * 
*             (SAVING THE CALLERS PAGE NUMBER)                        * 
*                                                                     * 
** INPUT    - K4TCBP  POINTER TO TCB, K4DIRECT  DIRECTION OF QUEUE    * 
*             TO BE PURGED (PARAMETERS)                               * 
*                                                                     * 
** OUTPUT   - B1TCB SET UP, QUEUE(S) PURGED                           * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PBRDPGE     - SAVE CALLERS PAGE NUMBER                  * 
*             PBPSWITCH   - SWITCH TO NEW (BIPS) PAGE NUMBER          * 
*             PGPURGEQUE  - PAGED PURGE QUEUE(S) ROUTINE              * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PBPURGEQUE (K4TCBP : B0BUFPTR; K4DIRECT : INTEGER); 
  
VAR 
  K4OLDPG : INTEGER;                        _CALLERS PAGE NUMBER       ?
  
BEGIN 
B1TCB      := K4TCBP;                       _SET GLOBAL TCB POINTER    ?
PBRDPGE    (K4OLDPG);                       _SAVE CALLERS PAGE         ?
PBPSWITCH  (K0PGBIP);                       _SWITCH TO BIPS PAGE       ?
PGPURGEQUE (K4DIRECT);                      _CALL PAGED ROUTINE        ?
PBPSWITCH  (K4OLDPG);                       _RESTORE CALLERS PAGE      ?
END;
_$J+
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*        P B B A C K C H E C K   -   TEST FOR U/L BACK DUE            * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$G-,R-,I-    NON RECURSIVE, INTERRUPTABLE ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW - THIS PROCEDURE TEST FOR U/L BACK(S) DUE, AND SENDS      * 
*             THEM. THE FORMULA USED TO DETERMINE THE NUMBER OF       * 
*             BACKS TO SEND TAKES INTO ACCOUNT THE DOWNLINE BLOCK     * 
*             LIMIT (DBL), THE NUMBER OF U/L BACKS DUE AND THE NUMBER * 
*             OF (TRANSMISSION) BLOCKS IN THE DOWNLINE TCB QUEUE.     * 
*                                                                     * 
** INPUT    - B1TCB  POINTER TO THE TCB                               * 
*                                                                     * 
** OUTPUT   - NR BACKS = DBL - (QCNT + (DBL - BCKDUE)                 * 
*            (NR BACKS = BCKDUE - QCNT)                               * 
*                                                                     * 
** EXTERNAL SUBROUTINES USED -                                        * 
*             PGULTS      - BUILD/SEND BACK UPLINE                    * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PBBACKCHECK;
  
VAR 
  K4BUFP  : B0BUFPTR;                       _WORK BUFFER POINTER       ?
  K4QCNT  : INTEGER;                        _NR TRANSMISSION BLOCK IN Q?
  K4BDUE  : INTEGER;                        _NR UPLINE BACKS DUE       ?
  
BEGIN 
IF B1TCB'.BSTCB.BSSTSTOP = FALSE            _AND STREAM NOT STOPPED    ?
THEN
  BEGIN 
  K4QCNT := 0;
  K4BUFP := B1TCB'.BSTCB.BSQPTR.BABUFPTR;   _GET DOWNLINE QUEUE PTR    ?
  K4BDUE := B1TCB'.BSTCB.BSBCKDUE;          _GET CURRENT NR BACKS DUE  ?
  WHILE K4BUFP " NIL DO 
    BEGIN                                   _INCREMENT COUNT FOR EACH  ?
    K4QCNT := K4QCNT + 1;                   _XMIT BLK IN D/L QUEUE     ?
    K4BUFP := K4BUFP'.BCCHAINS [QCHN];
    END;
  WHILE K4QCNT < K4BDUE DO                  _SEND BCKDUE - QCNT BACKS  ?
    BEGIN 
    K4QCNT         := K4QCNT + 1; 
    B1FLGWD.KTWORD := HTBACK; 
    PGULTS (NIL);                           _SEND BACK UPLINE          ?
    END;
  END;
END;   _ PROCEDURE PBBACKCHECK? 
